Functions
f32	fabsf (f32 f)

f64	fabs (f64 f)

f32	cosine (s16 arg0)

void	nuBoot (void)

void	boot_idle (void *data)

void	boot_main (void *data)

void	is_debug_init (void)

void	is_debug_panic (const char *message)

f32	signF (f32 val)

s32	func_8002ACDC (void)

void	load_obfuscation_shims (void)

void *	heap_malloc (s32 size)

void *	_heap_malloc (HeapNode *head, u32 size)

void *	_heap_malloc_tail (HeapNode *head, u32 size)

u32	_heap_free (HeapNode heapNodeList, void addrToFree)

void *	_heap_realloc (HeapNode heapNodeList, void addr, u32 newSize)

HeapNode *	_heap_create (HeapNode *addr, u32 size)

u32	dma_copy (Addr romStart, Addr romEnd, void *vramDest)

f32	rand_float (void)

void	copy_matrix (Matrix4f src, Matrix4f dest)

Shadow *	get_shadow_by_index (s32 index)

s32	get_time_freeze_mode (void)

void	render_player_model (void)

s32	is_picking_up_item (void)

f32	integrate_gravity (void)

void	gravity_use_fall_parms (void)

f32	get_clamped_angle_diff (f32, f32)

b32	startup_fade_screen_in (s16 subtractAlpha)

b32	startup_fade_screen_out (s16 addAlpha)

void	startup_fade_screen_update (void)

u32	get_entity_type (s32 arg0)

Entity *	get_entity_by_index (s32 index)

s32	create_entity (EntityBlueprint *bp,...)

void	entity_shattering_idle (Entity *entity)

void	show_damage_fx (Actor *actor, f32 x, f32 y, f32 z, s32 damage)

b32	entity_raycast_down (f32 , f32 , f32 , f32 , f32 , f32 )
	Mostly used for shadows.

void	step_game_loop (void)

s32	resume_all_group (s32 groupFlags)

f32	length2D (f32 x, f32 y)

void	player_input_to_move_vector (f32 angle, f32 magnitude)

void	game_input_to_move_vector (f32 x, f32 y)

void	exec_ShakeCamX (s32 arg0, s32 arg1, s32 arg2, f32 arg3)

void	exec_ShakeCam1 (s32 arg0, s32 arg1, s32 arg2)

f32	player_get_side_angle (void)

void	draw_number (s32 value, s32 x, s32 y, s32 variableWidthChars, s32 palette, s32 opacity, u16 style)

void	set_entity_model_flags (s32 idx, s32 newFlags)

void	clear_entity_model_flags (s32 idx, s32 newFlags)

void	exec_entity_model_commandlist (s32 idx)

RenderTask *	queue_render_task (RenderTask *task)

s32	create_mesh_animator (s16 animPos, s16 animBuffer)

void	load_mesh_animator_tree (s32 index, StaticAnimatorNode **tree)

void	setup_pause_menu_tab (MenuWindowBP *bpArray, s32 arraySize)

s32	draw_ci_image_with_clipping (u8 raster, s32 width, s32 height, s32 fmt, s32 bitDepth, u16 palette, s16 posX, s16 posY, u16 clipULx, u16 clipULy, u16 clipLRx, u16 clipRLy, u8 opacity)

void	render_frame (s32 flag)

void	clear_windows (void)

void	update_window_hierarchy (s32 windowIndex, u8 arg1)

void	get_msg_properties (s32 msgID, s32 height, s32 width, s32 maxLineChars, s32 numLines, s32 maxLinesPerPage, s32 arg6, u16 charset)

void	replace_window_update (s32 idx, s8 arg1, WindowUpdateFunc pendingFunc)

void	decode_yay0 (void src, void dst)

s32	ai_check_player_dist (Enemy *enemy, s32 arg1, f32 arg2, f32 arg3)

void	pause_init (void)

void	pause_handle_input (s32 buttonsPressed, s32 buttonsHeld)

void	pause_cleanup (void)

void	filemenu_init (s32 mode)

void	filemenu_cleanup (void)

void	filemenu_update (void)

s32	filemenu_get_exit_mode (void)

void	filemenu_set_selected (MenuPanel *menu, s32 col, s32 row)

void	filemenu_set_cursor_alpha (s32 arg0)

void	filemenu_set_cursor_goal_pos (s32 windowIndex, s32 posX, s32 posY)

u8 *	filemenu_get_menu_message (s32 idx)

void	gfx_task_background (void)

void	update_enemy_shadows (void)

void	update_hero_shadows (void)

void	appendGfx_background_texture (void)

void	appendGfx_enemy_actor (void *)

void	appendGfx_enemy_actor_blur (void *)

void	appendGfx_enemy_actor_reflection (void *)

void	appendGfx_partner_actor (void *)

void	appendGfx_partner_actor_blur (void *)

void	appendGfx_partner_actor_reflection (void *)

void	appendGfx_player_actor (void *)

void	appendGfx_player_actor_blur (Actor *)

void	appendGfx_player_actor_reflection (void *)

void	force_disable_actor_blur (Actor *)

void	player_handle_floor_collider_type (s32 colliderID)

f32	player_fall_distance (void)

void	func_800E4AD8 (s32 arg0)

f32	player_check_collision_below (f32, s32 *colliderID)

b32	can_trigger_loading_zone (void)

void	update_damage_popups (void)

void	show_action_rating (s32, Actor *, f32, f32, f32)

s32	render_with_adjusted_palettes (s32, ActorPart *, s32, Matrix4f, s32)

HeapNode *	general_heap_create (void)

void *	general_heap_malloc (s32 size)

s32	general_heap_free (void *data)

s32	integer_log (s32 number, u32 base)

void	set_battle_stage (s32)

void	load_battle (s32)

void	entity_Shadow_init (Shadow *entity)

void	entity_SaveBlock_idle (Entity *entity)

void	entity_SaveBlock_pause_game (void)

void	entity_SaveBlock_resume_game (void)

void	entity_SaveBlock_save_data (void)

void	entity_SaveBlock_show_tutorial_message (Entity *entity)

void	entity_SaveBlock_wait_for_close_tutorial (Entity *entity)

void	entity_SaveBlock_show_choice_message (void)

void	entity_SaveBlock_show_result_message (void)

void	entity_SaveBlock_wait_for_close_result (Entity *entity)

void	entity_SaveBlock_wait_for_close_choice (Entity *entity)

void	entity_SaveBlock_init (Entity *entity)

void	entity_GreenStompSwitch_idle (Entity *entity)

void	entity_GreenStompSwitch_retract (Entity *entity)

void	entity_GreenStompSwitch_extend (Entity *entity)

void	entity_HugeBlueSwitch_idle (Entity *entity)

void	entity_small_switch_idle (Entity *entity)

void	entity_RedSwitch_wait_and_reset (Entity *entity)

void	entity_base_switch_anim_init (Entity *entity)

s32	entity_RedSwitch_animate_scale (Entity *entity)

void	entity_base_switch_start_bound_script (Entity *entity)

void	entity_base_switch_animate_scale (Entity *entity)

void	entity_base_switch_init (Entity *entity)

f32	entity_block_hit_init_scale (Entity *entity)

void	entity_block_hit_animate_scale (Entity *entity)

s32	entity_block_handle_collision (Entity *entity)

void	entity_BlueSwitch_init (Entity *entity)

void	entity_HugeBlueSwitch_init (Entity *entity)

s32	dispatch_damage_event_actor_0 (Actor *actor, s32 damageAmount, s32 event)

MessagePrintState *	msg_get_printer_for_msg (s32 msgID, s32 *a1)

s32	msg_printer_load_msg (s32 msgID, MessagePrintState *printer)

void	msg_printer_set_origin_pos (MessagePrintState *msgPrintState, s32 x, s32 y)

void	get_screen_coords (s32 camID, f32 x, f32 y, f32 z, s32 screenX, s32 screenY, s32 *screenZ)

void	parent_collider_to_model (s16 colliderID, s16 modelIndex)

void	clone_model (u16 srcModelID, u16 newModelID)

struct Model *	get_model_from_list_index (s32 listIndex)

s32	create_model_animator (s16 *animPos)

s32	get_model_list_index_from_tree_index (s32 treeIndex)

s32	get_transform_group_index (s32)

void	get_model_center_and_size (u16 modelID, f32 centerX, f32 centerY, f32 centerZ, f32 sizeX, f32 sizeY, f32 sizeZ)

HitID	collision_main_above (void)

void	collision_lava_reset_check_additional_overlaps (void)

s32	player_test_lateral_overlap (s32, PlayerStatus , f32 , f32 , f32 , f32, f32)

Npc *	peach_make_disguise_npc (s32 peachDisguise)

void	peach_set_disguise_anim (AnimID)

s32	draw_box (s32 flags, WindowStyle windowStyle, s32 posX, s32 posY, s32 posZ, s32 width, s32 height, u8 opacity, u8 darkening, f32 scaleX, f32 scaleY, f32 rotX, f32 rotY, f32 rotZ, void(fpDrawContents)(s32, s32, s32, s32, s32, s32, s32), void drawContentsArg0, Matrix4f rotScaleMtx, s32 translateX, s32 translateY, Matrix4f outMtx)

s32	get_msg_width (s32 msgID, u16 charset)

s32	partner_can_open_world_menus (void)

s32	disable_player_static_collisions (void)

s32	disable_player_input (void)

void	func_80027088 (s32)

void	set_time_freeze_mode (s32)
	Time freeze modes: 0: none 1: NPCs move, can't be interacted with 2: NPCs don't move, no partner ability, can't interact, can't use exits 3: NPCs don't more or animate 4: NPCs can move, animations don't update, can use exits.

s32	get_map_IDs_by_name (const char mapName, s16 areaID, s16 *mapID)

void	get_map_IDs_by_name_checked (const char mapName, s16 areaID, s16 *mapID)
	Same as get_map_IDs_by_name, but will panic if the map doesn't exist.

void	transform_point (Matrix4f mtx, f32 inX, f32 inY, f32 inZ, f32 inS, f32 outX, f32 outY, f32 outZ, f32 outW)

void	try_player_footstep_sounds (s32 arg0)

void	phys_update_interact_collider (void)

void	phys_reset_spin_history (void)

s32	phys_adjust_cam_on_landing (void)

s32	phys_should_player_be_sliding (void)

void	phys_init_integrator_for_current_state (void)

void	phys_player_land (void)

void	phys_main_collision_below (void)

void	phys_peach_update (void)

void	check_input_spin (void)

void	phys_set_player_sliding_check (b32(*funcPtr)(void))

void	phys_set_landing_adjust_cam_check (s32(*funcPtr)(void))

b32	npc_test_move_simple_without_slipping (s32, f32 , f32 , f32 *, f32, f32, f32, f32)

void	update_collider_transform (s16 colliderID)

void	get_collider_center (s32 colliderID, f32 x, f32 y, f32 *z)

s32	is_another_trigger_bound (Trigger , EvtScript script)

Trigger *	create_trigger (TriggerBlueprint *def)

s32	evt_trigger_on_activate_exec_script (Trigger *trigger)

Trigger *	get_trigger_by_id (s32 triggerID)

Actor *	get_actor (s32 actorID)

ActorPart *	get_actor_part (Actor *actor, s32 partID)

s32	add_coins (s32 amt)

s32	is_partner_ability_active (s32)

s32	count_power_plus (s32)

s32	phys_can_player_interact (void)

void	ai_enemy_play_sound (Npc *npc, s32 arg1, s32 arg2)

HitID	player_test_move_without_slipping (PlayerStatus , f32 , f32 , f32 , f32, f32, s32 *)
	Only used for Peach physics.

HitID	player_test_move_with_slipping (PlayerStatus playerStatus, f32 posX, f32 posY, f32 posZ, f32 speed, f32 heading)

s32	evt_get_variable (Evt *script, Bytecode var)

s32	evt_set_variable (Evt *script, Bytecode var, s32 value)

f32	evt_get_float_variable (Evt *script, Bytecode var)

f32	evt_set_float_variable (Evt *script, Bytecode var, f32 value)

s32	evt_get_variable_index (Evt *script, s32 var)

void	set_script_timescale (Evt *script, f32 timescale)

f32	sin_deg (f32 x)

f32	cos_deg (f32 x)

f32	sin_rad (f32 x)

f32	cos_rad (f32 x)

s32	round (f32)

f32	atan2 (f32 startX, f32 startZ, f32 endX, f32 endZ)

f32	clamp_angle (f32 theta)

s32	sign (s32 value)

b32	check_player_action_debug (void)

s32	battle_heap_create (void)

s32	test_ray_zones (f32 startX, f32 startY, f32 startZ, f32 dirX, f32 dirY, f32 dirZ, f32 hitX, f32 hitY, f32 hitZ, f32 hitDepth, f32 nx, f32 ny, f32 *nz)

s32	test_ray_colliders (s32 ignoreFlags, f32 startX, f32 startY, f32 startZ, f32 dirX, f32 dirY, f32 dirZ, f32 hitX, f32 hitY, f32 hitZ, f32 hitDepth, f32 hitNx, f32 hitNy, f32 *hitNz)

s32	test_ray_entities (f32 startX, f32 startY, f32 startZ, f32 dirX, f32 dirY, f32 dirZ, f32 hitX, f32 hitY, f32 hitZ, f32 hitDepth, f32 hitNx, f32 hitNy, f32 *hitNz)
	Test a general ray from a given starting position and direction against all entities.

void	mem_clear (void *data, s32 numBytes)

void	startup_set_fade_screen_color (s16 color)

void	startup_set_fade_screen_alpha (s16 alpha)

f32	get_xz_dist_to_player (f32, f32)

void	func_800E06C0 (s32)

void	close_status_bar (void)

Evt *	func_802C39F8 (Evt parentScript, Bytecode nextLine, s32 newState)

Evt *	start_child_script (Evt parentScript, EvtScript source, s32 initialState)

Evt *	restart_script (Evt *script)

void	clear_virtual_entity_list (void)

void	reset_model_animators (void)

void	init_virtual_entity_list (void)

void	init_model_animators (void)

void	play_model_animation (s32, s16 *)

s32	heap_free (void *ptr)

void	load_battle_hit_asset (const char *hitName)

void	load_data_for_models (struct ModelNode *model, s32 romOffset, s32 size)

void	load_player_actor (void)

void	btl_state_update_normal_start (void)

void	btl_state_draw_normal_start (void)

void	btl_state_update_begin_turn (void)

void	btl_state_draw_begin_turn (void)

void	btl_state_update_begin_player_turn (void)

void	btl_state_draw_begin_player_turn (void)

void	btl_state_update_switch_to_player (void)

void	btl_state_draw_switch_to_player (void)

void	btl_state_update_begin_partner_turn (void)

void	btl_state_draw_begin_partner_turn (void)

void	btl_state_update_switch_to_partner (void)

void	btl_state_draw_switch_to_partner (void)

void	btl_state_update_9 (void)

void	btl_state_draw_9 (void)

void	btl_state_update_prepare_menu (void)

void	btl_state_draw_prepare_menu (void)

void	btl_state_update_end_turn (void)

void	btl_state_draw_end_turn (void)

void	btl_state_update_1C (void)

void	btl_state_draw_1C (void)

void	btl_state_update_victory (void)

void	btl_state_draw_victory (void)

void	btl_state_update_end_training_battle (void)

void	btl_state_draw_end_training_battle (void)

void	btl_state_update_end_battle (void)

void	btl_state_draw_end_battle (void)

void	btl_state_update_defend (void)

void	btl_state_draw_defend (void)

void	btl_state_update_run_away (void)

void	btl_state_draw_run_away (void)

void	btl_state_update_defeat (void)

void	btl_state_draw_defeat (void)

void	btl_state_update_change_partner (void)

void	btl_state_draw_change_partner (void)

void	btl_state_update_player_move (void)

void	btl_state_draw_player_move (void)

void	btl_state_update_end_player_turn (void)

void	btl_state_update_partner_move (void)

void	btl_state_draw_end_player_turn (void)

void	btl_state_draw_partner_move (void)

void	btl_state_update_end_partner_turn (void)

void	btl_state_draw_end_partner_turn (void)

void	btl_state_update_next_enemy (void)

void	btl_state_draw_next_enemy (void)

void	btl_state_update_enemy_move (void)

void	btl_state_draw_enemy_move (void)

void	btl_state_update_first_strike (void)

void	btl_state_draw_first_stike (void)

void	btl_state_update_partner_striking_first (void)

void	btl_state_draw_partner_striking_first (void)

void	btl_state_update_enemy_striking_first (void)

void	btl_state_draw_enemy_striking_first (void)

void	btl_state_update_end_demo_battle (void)

void	btl_state_draw_end_demo_battle (void)

void	btl_state_update_player_menu (void)

void	btl_state_draw_player_menu (void)

void	btl_state_update_partner_menu (void)

void	btl_state_draw_partner_menu (void)

void	btl_state_update_peach_menu (void)

void	btl_state_draw_peach_menu (void)

void	btl_state_update_twink_menu (void)

void	btl_state_draw_twink_menu (void)

void	btl_state_update_select_target (void)

void	btl_state_draw_select_target (void)

void	btl_state_update_22 (void)

void	btl_state_draw_22 (void)

void	btl_state_update_celebration (void)

void	btl_draw_upgrade_windows (s32)

void	btl_state_draw_celebration (void)

void	btl_bonk_cleanup (void)

void	set_actor_anim_by_ref (Actor , ActorPart , AnimID)

void	update_action_ratings (void)

void	update_health_bars (void)

s32	btl_cam_is_moving_done (void)

void	btl_popup_messages_update (void)

void	btl_popup_messages_draw_world_geometry (void)

void	func_80255FD8 (void)

void	set_actor_glow_pal (Actor *actor, s32 arg1)

void	btl_set_popup_duration (s32 duration)

void	switch_to_partner (s32 arg0)

s8	get_current_partner_id (void)

void	delete_trigger (Trigger *toDelete)

void	kill_script_by_ID (s32 id)

void	set_script_priority (Evt *script, s32 priority)

void	set_script_group (Evt *script, s32 groupFlags)

void	suspend_group_others (Evt *script, s32 groupFlags)

void	resume_group_others (Evt *script, s32 groupFlags)

s32	suspend_all_script (s32 id)

s32	resume_all_script (s32 id)

s32	create_shadow_type (s32 type, f32 x, f32 y, f32 z)

b32	is_point_outside_territory (s32 shape, f32 pointX, f32 pointY, f32 centerX, f32 centerY, f32 sizeX, f32 sizeZ)

b32	npc_raycast_down_around (s32, f32 , f32 , f32 , f32 , f32, f32)

b32	npc_raycast_down_sides (s32 ignoreFlags, f32 posX, f32 posY, f32 posZ, f32 hitDepth)

b32	npc_raycast_up (s32, f32 , f32 , f32 , f32 )

HitID	npc_raycast_up_corners (s32 ignoreFlags, f32 posX, f32 posY, f32 posZ, f32 hitDepth, f32 yaw, f32 radius)

HitID	player_raycast_up_corners (PlayerStatus , f32 , f32 , f32 , f32 *, f32)

HitID	player_raycast_below_cam_relative (PlayerStatus playerStatus, f32 outX, f32 outY, f32 outZ, f32 outLength, f32 hitRx, f32 hitRz, f32 hitDirX, f32 *hitDirZ)

b32	npc_test_move_taller_with_slipping (s32, f32 , f32 , f32 *, f32, f32, f32, f32)

b32	npc_test_move_simple_with_slipping (s32, f32 , f32 , f32 *, f32, f32, f32, f32)

s32	npc_test_move_complex_with_slipping (s32, f32 , f32 , f32 *, f32, f32, f32, f32)

EvtScript *	partner_get_enter_map_script (void)

void	partner_handle_before_battle (void)

void	partner_walking_update_player_tracking (Npc *partner)

void	partner_walking_update_motion (Npc *partner)

void	enable_partner_ai (void)

void	partner_walking_enable (Npc *partner, s32 val)

void	partner_flying_enable (Npc *partner, s32 val)

void	partner_flying_update_player_tracking (Npc *partner)

s32	partner_is_flying (void)

void	partner_flying_update_motion (Npc *partner)

void	partner_clear_player_tracking (Npc *partner)

void	partner_set_tether_distance (f32)

void	btl_delete_player_actor (Actor *player)

s32	cancel_message (MessagePrintState *msgPrintState)

void	set_message_images (MessageImageData *images)

void	kill_all_scripts (void)

s32	does_script_exist (s32 id)

s32	does_script_exist_by_ref (Evt *script)

Evt *	start_script (EvtScript *source, s32 priority, s32 initialState)

Evt *	start_script_in_group (EvtScript *source, u8 priority, u8 initialState, u8 groupFlags)

f32	get_player_normal_yaw (void)

void	set_standard_shadow_scale (Shadow *shadow, f32 scale)

void	set_npc_shadow_scale (Shadow *shadow, f32 height, f32 npcRadius)

void	set_npc_animation (Npc *npc, u32 animID)

void	set_peach_shadow_scale (Shadow *shadow, f32 scale)

s32	is_block_on_ground (Entity *block)

void	set_actor_anim (s32 actorID, s32 partID, AnimID animID)

void	set_actor_anim_rate (s32 actorID, s32 partID, f32 rate)

void	mdl_group_set_visibility (u16, s32, s32)

void	init_enter_world_shared (void)

s16	update_enter_map_screen_overlay (s16 *progress)

s16	update_exit_map_screen_overlay (s16 *progress)

void	set_screen_overlay_params_front (u8, f32)

void	set_screen_overlay_params_back (u8, f32)

void	set_screen_overlay_alpha (s32, f32)

void	get_screen_overlay_params (s32, u8 type, f32 zoom)

void	set_screen_overlay_color (s32, u8, u8, u8)

void	set_screen_overlay_center (s32, s32, s32, s32)

s32	rand_int (s32)

void	sort_consumables (void)
	Bubbles up player inventory items such that all ITEM_NONE values are at the bottom.

s32	is_ability_active (s32 arg0)

s32	is_starting_conversation (void)

f32	update_lerp (s32 easing, f32 start, f32 end, s32 elapsed, s32 duration)

void	sin_cos_deg (f32 rad, f32 outSinTheta, f32 outCosTheta)

void	set_main_pan_u (s32 texPannerID, s32 value)

void	set_main_pan_v (s32 texPannerID, s32 value)

void	set_aux_pan_u (s32 texPannerID, s32 value)

void	set_aux_pan_v (s32 texPannerID, s32 value)

void	enable_world_fog (void)

void	set_world_fog_dist (s32 start, s32 end)

void	set_world_fog_color (s32 r, s32 g, s32 b, s32 a)

s32	is_world_fog_enabled (void)

void	get_world_fog_color (s32 r, s32 g, s32 b, s32 a)

void	enable_entity_fog (void)

void	set_entity_fog_dist (s32 start, s32 end)

void	set_entity_fog_color (s32 r, s32 g, s32 b, s32 a)

struct ModelTransformGroup *	get_transform_group (s32 index)

void	mdl_make_transform_group (u16 modelID)

void	enable_transform_group (u16 modelID)

void	disable_transform_group (u16 modelID)

void	set_map_transition_effect (ScreenTransition)

void	set_tex_panner (struct Model *model, s32 texPannerID)

void	set_custom_gfx (s32 customGfxIndex, Gfx pre, Gfx post)

s32	make_item_entity (s32 itemID, f32 x, f32 y, f32 z, s32 itemSpawnMode, s32 pickupDelay, s32 angle, s32 pickupVar)

s32	make_item_entity_delayed (s32 itemID, f32 x, f32 y, f32 z, s32 itemSpawnMode, s32 pickupDelay, s32 pickupVar)

void	set_item_entity_position (s32 itemEntityIndex, f32 x, f32 y, f32 z)

ItemEntity *	get_item_entity (s32 itemEntityIndex)

s32	make_item_entity_nodelay (s32 itemID, f32 x, f32 y, f32 z, s32 itemSpawnMode, s32 pickupVar)

void	set_item_entity_flags (s32 itemEntityIndex, s32 flag)

void	clear_item_entity_flags (s32 index, s32 flags)

s32	create_worker_frontUI (void(updateFunc)(void), void(drawFunc)(void))

Worker *	get_worker (s32 idx)

Trigger *	bind_trigger_1 (EvtScript *script, s32 flags, s32 triggerFlagIndex, s32 triggerVar0, s32 triggerVar1, s32 priority)

void	set_cam_viewport (s16 id, s16 x, s16 y, s16 width, s16 height)

void	disable_player_shadow (void)

void	move_player (s32 duration, f32 heading, f32 speed)

s32	enable_player_input (void)

s32	enable_player_static_collisions (void)

b32	check_input_jump (void)

b32	check_input_hammer (void)

Npc *	resolve_npc (Evt *script, s32 npcIdOrPtr)

void	enable_npc_blur (Npc *npc)

void	disable_npc_blur (Npc *npc)

void	enable_partner_blur (void)

void	disable_partner_blur (void)

void	partner_initialize_data (void)

f32	dist2D (f32 ax, f32 ay, f32 bx, f32 by)

f32	dist3D (f32 ax, f32 ay, f32 az, f32 bx, f32 by, f32 bz)

void	add_vec2D_polar (f32 x, f32 y, f32 r, f32 theta)

enum AuResult	bgm_set_track_volumes (s32 playerIndex, s16 trackVolSet)

enum AuResult	bgm_clear_track_volumes (s32 playerIndex, s16 trackVolSet)

enum AuResult	bgm_set_variation (s32 playerIndex, s16 arg1)

void	bgm_quiet_max_volume (void)

void	bgm_reset_max_volume (void)

void	bgm_reset_volume (void)

s32	bgm_init_music_players (void)

s32	bgm_set_song (s32 playerIndex, s32 songID, s32 variation, s32 fadeOutTime, s16 volume)

void	bgm_set_battle_song (s32, s32)

void	bgm_push_battle_song (void)

s32	bgm_adjust_proximity (s32 playerIndex, s32 arg1, s16 arg2)

void	func_801491E4 (Matrix4f mtx, s32, s32, s32, s32, s32 alpha)

s32	func_8014A964 (s32 playerIndex, s32 songID, s32 variation, s32 fadeInTime, s16 arg4, s16 arg5)

void	basic_window_update (s32 windowIndex, s32 flags, s32 posX, s32 posY, s32 posZ, f32 scaleX, f32 scaleY, f32 rotX, f32 rotY, f32 rotZ, s32 darkening, s32 *opacity)

void	basic_hidden_window_update (s32 windowIndex, s32 flags, s32 posX, s32 posY, s32 posZ, f32 scaleX, f32 scaleY, f32 rotX, f32 rotY, f32 rotZ, s32 darkening, s32 *opacity)

void	create_current_pos_target_list (Actor *actor)

void	create_home_target_list (Actor *actor)

void	set_actor_yaw (s32 actorID, s32 yaw)

void	set_part_yaw (s32 actorID, s32 partID, s32 value)

void	add_part_decoration (ActorPart *part, s32 decorationIndex, s32 decorationType)

void	add_actor_decoration (Actor *actor, s32 decorationIndex, s32 decorationType)

void	remove_part_decoration (ActorPart *part, s32 decorationIndex)

void	remove_actor_decoration (Actor *actor, s32 decorationIndex)

s32	player_team_is_ability_active (Actor *actor, s32 ability)

void	create_part_shadow (s32 actorID, s32 partID)

void	remove_part_shadow (s32 actorID, s32 partID)

void	create_part_shadow_by_ref (s32 arg0, ActorPart *part)

void	spawn_drops (Enemy *enemy)

void	set_part_pal_adjustment (ActorPart *, s32)

char *	int_to_string (s32, char *, s32)

Evt *	get_script_by_index (s32 index)

Evt *	get_script_by_id (s32 id)

s32	partner_test_enemy_collision (Npc *enemy)

s32	get_lava_reset_pos (f32 x, f32 y, f32 *z)

void	start_rumble (s32, s32)

void	update_locomotion_state (void)

void	start_rumble_type (u32)

void	start_falling (void)

void	start_bounce_a (void)

void	start_bounce_b (void)

void	update_input (void)

void	update_max_rumble_duration (void)

void	mdl_reset_transform_flags (void)

void	update_workers (void)

void	update_triggers (void)

void	update_scripts (void)

void	update_messages (void)

void	update_entities (void)

void	func_80138198 (void)

void	bgm_update_music_settings (void)

s32	func_8014AD40 (void)

void	update_ambient_sounds (void)

void	update_windows (void)

void	player_render_interact_prompts (void)

void	func_802C3EE4 (void)

void	render_screen_overlay_backUI (void)

void	render_workers_backUI (void)

void	render_effects_UI (void)

void	render_window_root (void)

void	render_messages (void)

void	render_workers_frontUI (void)

void	render_screen_overlay_frontUI (void)

void	render_curtains (void)

void	fio_init_flash (void)

void	func_80028838 (void)

void	clear_screen_overlays (void)

void	bgm_reset_sequence_players (void)

void	reset_ambient_sounds (void)

void	poll_rumble (void)

void	bgm_pop_song (void)

void	bgm_push_song (s32 songID, s32 variation)

void	bgm_pop_battle_song (void)

s32	play_ambient_sounds (s32 fadeInTime, s32 fadeOutTime)

s32	get_fortress_key_count (void)

s32	subtract_fortress_keys (s32 amt)

s32	add_star_points (s32 amt)

s32	add_star_pieces (s32 amt)

s32	make_item_entity_at_player (s32 itemID, s32 arg1, s32 pickupMsgFlags)

void	set_action_state (s32 actionState)

s32	get_collider_flags (s32 colliderID)

void	suggest_player_anim_always_forward (AnimID anim)

void	suggest_player_anim_allow_backward (AnimID anim)

void	subtract_hp (s32 amt)

void	draw_status_ui (void)

void	open_status_bar_slowly (void)

void	suspend_all_group (s32 groupFlags)

void	kill_script (Evt *instanceToKill)

void	exec_entity_commandlist (Entity *entity)

void	show_start_recovery_shimmer (f32 x, f32 y, f32 z, s32 arg3)

void	show_recovery_shimmer (f32 x, f32 y, f32 z, s32 arg3)

void	show_next_damage_popup (f32 x, f32 y, f32 z, s32 damageAmount, s32)

void	add_xz_vec3f (Vec3f *vector, f32 speed, f32 angleDeg)

void	add_xz_vec3f_copy1 (Vec3f *vector, f32 speed, f32 angleDeg)

void	add_xz_vec3f_copy2 (Vec3f *vector, f32 speed, f32 angleDeg)

void	play_movement_dust_effects (s32 var0, f32 xPos, f32 yPos, f32 zPos, f32 angleDeg)

void	draw_prev_frame_buffer_at_screen_pos (s32, s32, s32, s32, f32)

void	func_8013A4D0 (void)

void	btl_draw_ui (void)

void	btl_restore_world_cameras (void)

void	btl_popup_messages_draw_ui (void)

void	btl_cam_set_target_pos (f32, f32, f32)

void	btl_cam_unfreeze (void)

void	deduct_current_move_fp (void)

void	load_partner_actor (void)

void	dispatch_event_partner (s32)

void	dispatch_event_player (s32)

s32	btl_are_all_enemies_defeated (void)

s32	btl_check_enemies_defeated (void)

s32	btl_check_player_defeated (void)

void	btl_show_battle_message (s32 messageIndex, s32 duration)

void	btl_update_ko_status (void)

void	reset_actor_turn_info (void)

void	startup_draw_prim_rect (s16 left, s16 top, s16 right, s16 bottom, u16 r, u16 g, u16 b, u16 a)

void	startup_draw_prim_rect_COPY (s16 left, s16 top, s16 right, s16 bottom, u16 r, u16 g, u16 b, u16 a)

void	btl_draw_prim_quad (u8 r, u8 g, u8 b, u8 a, u16 left, u16 top, u16 arg6, u16 arg7)

void	reset_all_actor_sounds (Actor *)

void	decrement_status_bar_disabled (void)

void	increment_status_bar_disabled (void)

void	btl_delete_actor (Actor *actor)

void	create_status_debuff (s32, s32)

void	create_status_static (s32, s32)

void	create_status_transparent (s32, s32)

void	remove_status_chill_out (s32)

void	remove_status_debuff (s32)

void	remove_status_icon_boost_hammer (s32)

void	remove_status_icon_boost_jump (s32)

void	remove_status_icon_boost_partner (s32)

void	remove_status_icon_danger (s32)

void	remove_status_icon_peril (s32)

void	remove_status_icon_surprise (s32)

void	remove_status_static (s32)

void	remove_status_transparent (s32)

void	remove_all_status_icons (s32)

s32	create_status_icon_set (void)

s32	find_item (s32)
	Search player inventory for `itemID` and return first matching array index.

void	enable_background_wave (void)

void	set_map_change_fade_rate (s16)

void	load_map_by_IDs (s16 areaID, s16 mapID, s16 loadType)

void	state_init_startup (void)

void	state_step_startup (void)

void	state_drawUI_startup (void)

void	state_init_logos (void)

void	state_step_logos (void)

void	state_drawUI_logos (void)

void	state_init_title_screen (void)

void	state_step_title_screen (void)

void	state_drawUI_title_screen (void)

void	state_init_enter_demo (void)

void	state_step_enter_world (void)

void	state_init_change_map (void)

void	state_step_change_map (void)

void	state_drawUI_change_map (void)

void	state_init_game_over (void)

void	state_step_game_over (void)

void	state_drawUI_game_over (void)

void	state_init_enter_world (void)

void	state_drawUI_enter_world (void)

void	state_init_world (void)

void	state_step_world (void)

void	state_drawUI_world (void)

void	state_init_battle (void)

void	state_step_battle (void)

void	state_drawUI_battle (void)

void	state_init_end_battle (void)

void	state_step_end_battle (void)

void	state_drawUI_end_battle (void)

void	state_init_pause (void)

void	state_step_pause (void)

void	state_drawUI_pause (void)

void	state_init_unpause (void)

void	state_step_unpause (void)

void	state_drawUI_unpause (void)

void	state_init_file_select (void)

void	state_step_file_select (void)

void	state_drawUI_file_select (void)

void	state_init_exit_file_select (void)

void	state_step_exit_file_select (void)

void	state_drawUI_exit_file_select (void)

void	state_init_intro (void)

void	state_step_intro (void)

void	state_drawUI_intro (void)

void	state_init_demo (void)

void	state_step_demo (void)

void	state_drawUI_demo (void)

void	btl_set_player_idle_anims (void)

void	shim_create_audio_system_obfuscated (void)

void	shim_load_engine_data_obfuscated (void)

void	shim_general_heap_create_obfuscated (void)

void	shim_battle_heap_create_obfuscated (void)

void	appendGfx_ispy_icon (void)

void	interact_inspect_setup (void)

void	interact_speech_setup (void)

void	pulse_stone_notification_setup (void)

void	appendGfx_speech_bubble (void)

void	appendGfx_pulse_stone_icon (void)

void	ispy_notification_setup (void)

void	initialize_curtains (void)

void	update_curtains (void)

void	set_curtain_scale_goal (f32 scale)

void	set_curtain_scale (f32 scale)

void	set_curtain_draw_callback (void(*callback)(void))

void	set_curtain_fade_goal (f32 fade)

void	set_curtain_fade (f32 fade)

void	crash_screen_init (void)

void	crash_screen_set_draw_info (u16 *frameBufPtr, s16 width, s16 height)

void	basic_ai_wander_init (Evt script, MobileAISettings npcAISettings, EnemyDetectVolume *territory)

void	basic_ai_wander (Evt script, MobileAISettings npcAISettings, EnemyDetectVolume *territory)

void	basic_ai_loiter (Evt script, MobileAISettings npcAISettings, EnemyDetectVolume *territory)

void	basic_ai_found_player_jump_init (Evt script, MobileAISettings npcAISettings, EnemyDetectVolume *territory)

void	basic_ai_found_player_jump (Evt script, MobileAISettings npcAISettings, EnemyDetectVolume *territory)

void	basic_ai_chase_init (Evt script, MobileAISettings npcAISettings, EnemyDetectVolume *territory)

void	basic_ai_chase (Evt script, MobileAISettings npcAISettings, EnemyDetectVolume *territory)

void	basic_ai_lose_player (Evt script, MobileAISettings npcAISettings, EnemyDetectVolume *territory)

void	basic_ai_suspend (Evt *script)

s32	create_worker_scene (void(updateFunc)(void), void(renderFunc)(void))

void	init_entity_models (void)

f32	phys_get_spin_history (s32 lag, s32 x, s32 y, s32 *z)

void	imgfx_update (u32, ImgFXType, s32, s32, s32, s32, s32)

s32	imgfx_appendGfx_component (s32, ImgFXTexture *, u32, Matrix4f)

void	imgfx_update_cache (void)

s32	imgfx_get_free_instances (s32)

void	free_worker (s32)

b32	ai_check_fwd_collisions (Npc npc, f32 time, f32 outYaw, f32 outDistFwd, f32 outDistCW, f32 *outDistCCW)

void	basic_ai_loiter_init (Evt script, MobileAISettings aiSettings, EnemyDetectVolume *territory)

void	PatrolAI_LoiterInit (Evt script, MobileAISettings aiSettings, EnemyDetectVolume *territory)

s32	func_80263230 (Actor , Actor )

void	set_part_glow_pal (ActorPart *, s32)

void	clear_actor_static_pal_adjustments (Actor *)

void	set_actor_flash_mode (Actor *actor, s32 arg1)

void	remove_player_buffs (s32)

s32	is_actor_health_bar_visible (Actor *)

void	sin_cos_rad (f32 rad, f32 outSinTheta, f32 outCosTheta)

void	load_font (s32 font)

void	load_font_data (Addr offset, u16 size, void *dest)

void *	load_asset_by_name (const char assetName, u32 decompressedSize)

Gfx *	mdl_get_copied_gfx (s32 copyIndex)

void	mdl_get_copied_vertices (s32 copyIndex, Vtx firstVertex, Vtx copiedVertices, s32 *numCopied)

void	mdl_draw_hidden_panel_surface (Gfx **arg0, u16 treeIndex)

b32	is_point_visible (f32 x, f32 y, f32 z, s32 depthQueryID, f32 screenX, f32 screenY)

void	set_screen_overlay_center_worldpos (s32 idx, s32 posIdx, s32 x, s32 y, s32 z)

void *	mdl_get_next_texture_address (s32)

s32	cancel_current_message (void)

void	draw_msg (s32 msgID, s32 posX, s32 posY, s32 opacity, s32 palette, u8 style)

void	mdl_get_shroud_tint_params (u8 r, u8 g, u8 b, u8 a)

s32	entity_base_block_idle (Entity *entity)

void	add_star_power (s32 amt)

s32	entity_can_collide_with_jumping_player (Entity *entity)

void	entity_base_block_init (Entity *entity)

s32	entity_start_script (Entity *entity)

void	init_item_entity_list (void)

void	init_script_list (void)

void	init_entity_data (void)

void	init_trigger_list (void)

void	partner_init_after_battle (s32 arg0)

void	load_map_script_lib (void)

void	remove_item_entity_by_index (s32 index)

void	set_entity_commandlist (Entity entity, s32 entityScript)

s32	is_player_dismounted (void)

void	func_800EF300 (void)

void	func_800EF314 (void)

void	func_800EF43C (void)

void	func_800EF3E4 (void)

void	enable_player_shadow (void)

s32	get_msg_lines (s32 messageID)

void	set_window_properties (s32 panelID, s32 posX, s32 posY, s32 width, s32 height, u8, void drawContents, void drawContentsArg, s8 parent)

void	set_window_update (s32 panelID, s32)

void	set_windows_visible (s32 groupIdx)

void	partner_disable_input (void)

void	partner_set_goal_pos (s32 x, s32 z)

void	close_message (MessagePrintState *msgPrintState)

void	show_foreground_models_unchecked (void)

void	hide_foreground_models_unchecked (void)

void	show_foreground_models (void)

void	hide_foreground_models (void)

void	btl_set_state (s32 battleState)

void	draw_entity_model_A (s32, Mtx *)

void	draw_entity_model_B (s32, Mtx , s32, Vec3s )

void	draw_entity_model_C (s32, Mtx *)

void	draw_entity_model_D (s32, Mtx , s32, Vec3s )

void	draw_entity_model_E (s32, Mtx *)

void	free_entity_model_by_index (s32 idx)

void	btl_cam_use_preset (s32)

void	btl_cam_set_params (b16, s16, s16, s16, s32, s32, s32)

void	btl_cam_set_zoffset (s16)

void	btl_cam_target_actor (s32)

void	btl_cam_set_zoom (s16)

void	btl_cam_move (s16)

void	btl_cam_disable_clamp_x (void)

void	initialize_battle (void)

void	dispatch_event_actor (Actor *, s32)

s32	dispatch_damage_event_actor_1 (Actor *actor, s32 damageAmount, s32 event)

void	reset_battle_status (void)

void	btl_show_variable_battle_message (s32, s32, s32)

s32	btl_is_popup_displayed (void)

void	btl_cam_use_preset_immediately (s32)

s32	inflict_status (Actor *, s32, s32)

s32	try_inflict_status (Actor *, s32, s32)

s32	inflict_status_set_duration (Actor *actor, s32 statusTypeKey, s32 statusDurationKey, s32 duration)

void	mdl_set_all_tint_type (s32)

void	load_model_animator_tree (s32, StaticAnimatorNode **)

s32	inflict_partner_ko (Actor *target, s32 statusTypeKey, s32 duration)

s32	get_defense (Actor actor, s32 defenseTable, s32 elementFlags)

void	btl_popup_messages_init (void)

void	remove_all_effects (void)

void	update_effects (void)

void	update_cameras (void)

void	clear_render_tasks (void)

void	clear_worker_list (void)

void	clear_printers (void)

void	clear_item_entity_data (void)

void	clear_player_data (void)

void	phys_update_jump (void)

void	phys_update_falling (void)

void	check_input_midair_jump (void)

void	collision_check_player_overlaps (void)

void	update_player_input (void)

void	phys_update_action_state (void)

void	collision_main_lateral (void)

void	player_surface_spawn_fx (void)

void	check_input_open_menus (void)

void	check_input_status_bar (void)

void	update_player (void)

void	enforce_hpfp_limits (void)

s32	should_collider_allow_interact (s32)

void	show_coin_counter (void)

void	hide_coin_counter_immediately (void)

void	hide_popup_menu (void)

void	destroy_popup_menu (void)

void	reset_player_status (void)

void	player_reset_data (void)

void	partner_reset_data (void)

s32	has_valid_conversation_npc (void)

s32	func_800E06D8 (void)

void	func_800E01DC (void)

void	collision_lateral_peach (void)

void	func_800E5520 (void)

void	clear_world_menus (void)

void	setup_status_bar_for_battle (void)

void	enable_status_bar_input (void)

void	disable_status_bar_input (void)

b32	can_control_status_bar (void)

void	status_bar_respond_to_changes (void)

void	status_bar_always_show_on (void)

void	status_bar_always_show_off (void)

void	star_power_shimmer_start (s32, f32, f32, f32)

void	star_power_shimmer_init (void)

void	star_power_shimmer_update (void)

void	star_power_shimmer_draw (void)

void	shop_open_item_select_popup (s32 mode)

void	hide_coin_counter (void)

void	set_message_text_var (s32 msgID, s32 index)

void	set_message_int_var (s32 value, s32 index)

void	open_status_bar_quickly (void)

void	show_immune_bonk (f32 x, f32 y, f32 z, s32, s32, s32)

void	show_primary_damage_popup (f32 x, f32 y, f32 z, s32 attack, s32 a)

s32	dispatch_damage_event_partner (s32 damageAmount, s32 event, s32 stopMotion)

void	disable_actor_blur (Actor *)

void	reset_actor_blur (Actor *)

void	enable_actor_blur (Actor *)

void	apply_shock_effect (Actor *)

void	part_glow_off (s32, ActorPart *, s32 yaw, b32 arg3)

void	part_flash_off (b32 isNpcSprite, ActorPart *part, s32 yaw, b32 isReflection)

void	part_flash_on (b32 isNpcSprite, ActorPart *part, s32 yaw, b32 isReflection)

void	_add_part_decoration (ActorPart *)

void	_remove_part_decoration (ActorPart *part, s32 decorationIndex)

void	remove_part_decor_none (ActorPart *, s32)

void	remove_part_decor_golden_flames (ActorPart *, s32)

void	remove_part_decor_sweat (ActorPart *, s32)

void	remove_part_decor_seeing_stars (ActorPart *, s32)

void	remove_part_decor_red_flames (ActorPart *, s32)

void	remove_part_decor_smoky_trail (ActorPart *, s32)

void	remove_part_decor_fiery_trail (ActorPart *, s32)

void	remove_part_decor_whirlwind (ActorPart *, s32)

void	remove_part_decor_steam (ActorPart *, s32)

void	remove_part_decor_sparkles (ActorPart *, s32)

void	remove_part_decor_bowser_aura (ActorPart *, s32)

void	remove_part_decor_radiating_stars (ActorPart *, s32)

void	status_bar_ignore_changes (void)

void	imgfx_release_instance (u32)

void	set_script_flags (Evt *script, s32 flags)

void	clear_script_flags (Evt *script, s32 flags)

void	disable_player_blur (void)

void	enable_player_blur (void)

void	reset_player_blur (void)

void	force_disable_player_blur (void)

void	force_disable_player_blur_immediately (void)

void	func_8023E104 (void)

void	func_8023E11C (void)

void	set_goal_pos_to_part (ActorState *state, s32 actorID, s32 partID)

void	init_encounters_ui (void)

void	initialize_collision (void)

void	render_entities (void)

void	render_player (void)

void	render_workers_scene (void)

void	render_effects_scene (void)

s32	get_asset_offset (char , s32 )

void	initialize_status_bar (void)

void	status_bar_start_blinking_fp (void)

s32	is_status_bar_visible (void)

void	status_bar_start_blinking_starpoints (void)

void	status_bar_stop_blinking_starpoints (void)

void	status_bar_start_blinking_hp (void)

void	status_bar_start_blinking_sp (void)

void	status_bar_stop_blinking_fp (void)

void	status_bar_stop_blinking_hp (void)

void	status_bar_stop_blinking_sp (void)

void	status_bar_start_blinking_sp_bars (s32 numBarsToBlink)

void	status_bar_draw_number (s32 iconID, s32 x, s32 y, s32 value, s32 numDigits)

void	status_bar_draw_stat (s32 id, s32 x, s32 y, s32, s32)

void	set_background_size (s16, s16, s16, s16)

void	set_background (BackgroundHeader *)

void	set_max_star_power (s8)

void	sync_status_bar (void)

void	create_cameras (void)

void	func_80045AC0 (void)

void	func_8005AF84 (void)

void	npc_follow_init (Npc , s32, FollowAnims , f32, f32, s32, s32)

void	npc_update_npc_tracking (Npc *)

void	npc_follow_npc (Npc *)

void	create_encounters (void)

void	update_encounters_neutral (void)

void	update_encounters_pre_battle (void)

void	update_encounters_conversation (void)

void	update_encounters_post_battle (void)

void	load_map_bg (char *optAssetName)

void	reset_background_settings (void)

void	func_80138188 (void)

void	func_80266970 (Actor *)

void	show_actor_health_bar (Actor *)

void	hide_actor_health_bar (Actor *)

void	clear_part_pal_adjustment (ActorPart *)

void	calculate_camera_yinterp_rate (void)

void	load_tattle_flags (s32)

s32	use_consumable (s32 invSlot)

void	remove_consumable (void)

void	delete_shadow (s32)

void	partner_reset_tether_distance (void)

void	save_tattle_flags (s32)

void	update_merlee_messages (void)

void	draw_merlee_messages (void)

void	show_merlee_message (s16, s16)

s32	is_merlee_message_done (void)

void	close_action_command_instruction_popup (void)

void	draw_encounters_conversation (void)

void	draw_encounters_post_battle (void)

void	draw_encounters_pre_battle (void)

void	draw_encounters_neutral (void)

void	show_first_strike_message (void)

void	entity_upgrade_block_hide_content (s32)

s32	lookup_defense (s32 *, s32)

s32	lookup_status_chance (s32 *, s32)

void	peach_check_for_parasol_input (void)

void	peach_sync_disguise_npc (void)

b32	check_conversation_trigger (void)

void	clear_player_status (void)

void	clear_entity_models (void)

void	bind_entity_model_setupGfx (s32 idx, void setupGfxCallbackArg0, void(fpSetupGfxCallback)(void *))

void	clear_animator_list (void)

void	clear_model_data (void)

void	init_sprite_shading_data (void)

void	clear_sprite_shading_data (void)

void	clear_character_set (void)

void	clear_trigger_data (void)

void	clear_script_list (void)

void	clear_entity_data (b32)

void	clear_effect_data (void)

void	clear_saved_variables (void)

void	clear_area_flags (void)

f32	get_player_normal_pitch (void)

void	partner_kill_ability_script (void)

void	func_800EF3D4 (s32)

void	mdl_update_transform_matrices (void)

void	mdl_group_set_custom_gfx (u16, s32, s32, b32)

void	backup_map_collision_data (void)

void	reset_status_bar (void)

void	btl_save_world_cameras (void)

void	load_battle_section (void)

void	btl_update (void)

void	update_item_entities (void)

void	restore_map_collision_data (void)

void	mdl_load_all_textures (struct ModelNode *model, s32 romOffset, s32 size)

void	mdl_calculate_model_sizes (void)

Function Documentation

◆ fabsf()

f32 fabsf ( f32 f )

Referenced by action_update_run(), action_update_sliding(), action_update_use_spinning_flower(), action_update_use_tweester(), action_update_walk(), appendGfx_background_texture(), ArcsinDeg(), atan2(), AvoidPlayerAI_ChaseInit(), basic_ai_chase_init(), basic_ai_check_player_dist(), btl_main_menu_draw(), calculate_line_segment_intersection(), calculate_segment_intersection(), check_conversation_trigger(), clamp_angle(), CleftAI_CanSeePlayer(), collision_main_above(), collision_main_lateral(), create_shading_palette(), Entity_BoardedFloor_update_fragments(), entity_BombableRock_update_fragments(), entity_Chest_idle(), entity_shattering_idle(), entity_Signpost_idle(), entity_Tweester_has_reached_target(), entity_WoodenCrate_update_fragments(), FlyingAI_LosePlayer(), FlyingAI_Wander(), FlyingNoAttackAI_12(), get_clamped_angle_diff(), get_maximum_interp_delta(), GuardAI_ChaseInit(), HoppingAI_Chase(), HoppingAI_Hop(), MagikoopaAI_CanShootSpell(), MeleeHitbox_CanSeePlayer(), npc_do_player_collision(), npc_find_closest(), npc_find_closest_simple(), npc_follow_npc(), npc_get_render_yaw(), npc_raycast_down(), npc_raycast_down_around(), npc_raycast_down_sides(), npc_test_move_complex_with_slipping(), npc_test_move_simple_with_slipping(), npc_test_move_simple_without_slipping(), npc_test_move_taller_with_slipping(), npc_try_apply_gravity(), npc_try_snap_to_ground(), partner_do_player_collision(), partner_flying_follow_player(), partner_flying_update_motion(), partner_get_out(), partner_move_to_goal(), partner_walking_follow_player(), partner_walking_update_motion(), PatrolAI_ChaseInit(), phys_is_on_sloped_ground(), player_check_collision_below(), player_raycast_below(), player_update_sprite(), ProjectileHitbox_GetUsableProjectileID(), SentinelAI_ChaseInit(), SentinelAI_Descend(), sfx_compute_spatialized_sound_params_with_depth(), test_player_entity_aabb(), update_camera_from_controller(), update_camera_interp_pos(), update_encounters_neutral(), and update_unused_lead_amt().

◆ fabs()

f64 fabs ( f64 f )

Referenced by action_update_sliding(), action_update_state_23(), entity_HiddenPanel_idle(), entity_HiddenPanel_is_item_on_top(), entity_Padlock_push_player(), entity_Tweester_idle(), func_802BB0A0_E2D9D0(), func_802BB8D4_E2E204(), func_802BC0F0_E2EA20(), parasol_get_npc(), partner_flying_follow_player(), partner_move_to_goal(), player_raycast_general(), sfx_compute_spatialized_sound_params_ignore_depth(), test_mounting_height_adjustment(), and update_riding_physics().

◆ cosine()

f32 cosine ( s16 arg0 )

Definition at line 353 of file 43F0.c.

                     {
    s16 temp360;
    s16 idx;
 
    temp360 = arg0 % 360;
 
    if (temp360 < 0) {
        temp360 += 360;
    }
 
    idx = temp360 % 180;
    if (idx > 90) {
        idx = 180 - idx;
    }
 
    if (temp360 >= 180) {
        return -sCosineTable[idx];
    } else {
        return sCosineTable[idx];
    }
}

Referenced by appendGfx_message(), imgfx_appendGfx_mesh(), msg_draw_choice_pointer(), msg_draw_speech_arrow(), msg_update_rewind_arrow(), npc_update_decoration_charged(), part_glow_on(), and SentinelAI_Descend().

◆ nuBoot()

void nuBoot ( void )

◆ boot_idle()

void boot_idle ( void * data )

◆ boot_main()

void boot_main ( void * data )

Definition at line 52 of file main.c.

                           {
#if VERSION_JP
    if (osTvType == OS_TV_NTSC) {
        nuGfxDisplayOff();
        osViSetMode(&osViModeNtscLan1);
        osViSetSpecialFeatures(OS_VI_GAMMA_OFF | OS_VI_GAMMA_DITHER_OFF | OS_VI_DIVOT_ON | OS_VI_DITHER_FILTER_ON);
        nuGfxDisplayOff();
    } else {
        PANIC();
    }
#else // not VERSION_JP
    if (osTvType == OS_TV_NTSC) {
        osViSetMode(&osViModeNtscLan1);
        osViSetSpecialFeatures(OS_VI_GAMMA_OFF | OS_VI_GAMMA_DITHER_OFF | OS_VI_DIVOT_ON | OS_VI_DITHER_FILTER_ON);
    } else if (osTvType == OS_TV_MPAL) {
        osViSetMode(&osViModeMpalLan1);
        osViSetSpecialFeatures(OS_VI_GAMMA_OFF | OS_VI_GAMMA_DITHER_OFF | OS_VI_DIVOT_ON | OS_VI_DITHER_FILTER_ON);
    } else {
        PANIC();
    }
 
    nuGfxDisplayOff();
    crash_screen_init();
#endif
 
#if !VERSION_IQUE
    is_debug_init();
#endif
    nuGfxInit();
    gGameStatusPtr->contBitPattern = nuContInit();
 
#if !VERSION_IQUE
    load_obfuscation_shims();
#endif
    shim_create_audio_system_obfuscated();
    shim_load_engine_data_obfuscated();
 
    nuGfxFuncSet((NUGfxFunc) gfxRetrace_Callback);
    nuGfxPreNMIFuncSet(gfxPreNMI_Callback);
    nuGfxTaskEndFunc = gfx_task_end_callback;
    gRandSeed += osGetCount();
    nuGfxDisplayOn();
 
    while (TRUE) {}
}

◆ is_debug_init()

void is_debug_init ( void )

Definition at line 19 of file is_debug.c.

                         {
    osEPiWriteIo(nuPiCartHandle, (u32) &gISVDbgPrnAdrs->put, 0);
    osEPiWriteIo(nuPiCartHandle, (u32) &gISVDbgPrnAdrs->get, 0);
    osEPiWriteIo(nuPiCartHandle, (u32) &gISVDbgPrnAdrs->magic, ASCII_TO_U32('I', 'S', '6', '4'));
}

Referenced by boot_main().

◆ is_debug_panic()

void is_debug_panic ( const char * message )

Definition at line 93 of file is_debug.c.

                                         {
    crash_screen_set_assert_info(message);
    *(volatile u32*)0 = 0; // Crash so we can see the crash screen
}

◆ signF()

f32 signF ( f32 val )

Definition at line 556 of file 43F0.c.

                   {
    f32 sign;
 
    if (!(val > 0.0f)) {
        sign = -1.0f;
        if (!(val < 0.0f)) {
            sign = 0.0f;
        }
    } else {
        sign = 1.0f;
    }
 
    return sign;
}

Referenced by FireBarAI_Callback().

◆ func_8002ACDC()

s32 func_8002ACDC ( void )

Definition at line 30 of file heap.c.

                        {
    return 0;
}

Referenced by state_step_end_battle(), and state_step_unpause().

◆ load_obfuscation_shims()

void load_obfuscation_shims ( void )

Definition at line 22 of file load_obfuscation_shims.c.

                                  {
    s32 (*readFunc)(OSPiHandle*, u32, u32*);
    s32 (*readFunc2)(OSPiHandle*, u32, u32*);
    s8* vramDest = obfuscated_obfuscation_shims_VRAM;
    s8* romStart = obfuscated_obfuscation_shims_ROM_START;
    s32 seed;
    u32 hash;
    u32 thisInsn;
    u32 thisInsn2;
    u32 prevInsn;
    u8* it;
 
    // vramDest
    readFunc = osEPiReadIo;
    seed = 0x0B112D28;
    hash = 0;
    readFunc(nuPiCartHandle, 0xB0000D10, &thisInsn);
    seed -= thisInsn;
    prevInsn = 0;
 
    for (it = battle_heap_create_obfuscated_ROM_START; it < battle_heap_create_obfuscated_ROM_END; it += 4) {
        readFunc(nuPiCartHandle, (u32)it, &thisInsn);
        hash += LOWER(thisInsn) + UPPER(thisInsn);
 
        if (OPCODE(prevInsn) == LUI && (OPCODE(thisInsn) == ADDIU || OPCODE(thisInsn) == LW)) {
            if (GET_RS(thisInsn) == GET_RT(prevInsn) && GET_RS(thisInsn) == GET_RT(thisInsn)) {
                hash -= LOWER(thisInsn);
                hash -= LOWER(prevInsn);
            }
        }
 
        if (OPCODE(thisInsn) == JAL) {
            hash -= LOWER(thisInsn) + (UPPER(thisInsn) & 0xFC00);
        }
 
        prevInsn = thisInsn;
    }
    vramDest += seed + 0x2A4EB6 - hash;
 
    // romStart
    readFunc2 = osEPiReadIo;
    seed = 0x18F414AB;
    hash = 0;
    readFunc2(nuPiCartHandle, 0xB0000E38, &thisInsn2);
    seed -= thisInsn2;
    prevInsn = 0;
 
    for (it = obfuscation_shims_ROM_START; it < obfuscation_shims_ROM_END; it += 4) {
        readFunc2(nuPiCartHandle, (u32)it, &thisInsn2);
        hash += LOWER(thisInsn2) + UPPER(thisInsn2);
 
        if (OPCODE(prevInsn) == LUI && (OPCODE(thisInsn2) == ADDIU || OPCODE(thisInsn2) == LW)) {
            if (GET_RS(thisInsn2) == GET_RT(prevInsn) && GET_RS(thisInsn2) == GET_RT(thisInsn2)) {
                hash -= LOWER(thisInsn2);
                hash -= LOWER(prevInsn);
            }
        }
 
        if (OPCODE(thisInsn2) == JAL) {
            hash -= LOWER(thisInsn2) + (UPPER(thisInsn2) & 0xFC00);
        }
        prevInsn = thisInsn2;
    }
    romStart += seed + 0xED41C - hash;
 
    dma_copy(romStart, obfuscation_shims_ROM_END, vramDest);
}

Referenced by boot_main(), load_map_by_IDs(), and state_step_battle().

◆ heap_malloc()

void * heap_malloc ( s32 size )

Definition at line 34 of file heap.c.

                            {
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        return general_heap_malloc(size);
    } else {
        return _heap_malloc(&heap_battleHead, size);
    }
}

Referenced by add_anim_node(), ALT_clear_hud_element_cache(), ALT_load_entity_model(), clear_virtual_entity_list(), clone_model(), create_actor(), create_encounters(), create_entity(), create_mesh_animator(), create_model_animator(), create_npc_impl(), create_shadow_from_data(), create_trigger(), create_worker_backUI(), create_worker_frontUI(), create_worker_scene(), enable_npc_blur(), evt_handle_allocate_array(), func_802C39F8(), get_asset_offset(), hud_element_create(), imgfx_load_anim(), imgfx_mesh_anim_update(), imgfx_update(), load_asset_by_name(), load_battle_hit_asset(), load_entity_model(), load_map_hit_asset(), load_partner_actor(), load_path_data(), load_player_actor(), make_item_entity(), make_item_entity_at_player(), mdl_create_model(), mdl_make_local_vertex_copy(), mdl_make_transform_group(), msg_copy_to_print_buffer(), npc_follow_init(), reset_model_animators(), show_immune_bonk(), start_child_script(), start_script(), start_script_in_group(), state_init_logos(), state_init_title_screen(), and update_item_entity_collectable().

◆ _heap_malloc()

void * _heap_malloc	(	HeapNode *	head,
		u32	size )

Definition at line 78 of file 43F0.c.

                                             {
    HeapNode* nextHeapNode;
    HeapNode* pPrevHeapNode = NULL;
    u32 newBlockSize;
    u32 curBlockLength;
    HeapNode* curHeapNode;
    u32 smallestBlockFound;
    u16 HeapEntryID;
    u16 HeapEntryID2;
 
    // must allocate 16 bytes or more at minimum or fail
    size = ALIGN16(size);
    if (!size) {
        debug_printf("warning: attempt to malloc less than 16 bytes\n");
        return NULL;
    }
 
    smallestBlockFound = 0;
    nextHeapNode = NULL;
 
    // find the smallest block we can fit into in the free list
    for (curHeapNode = head; ; curHeapNode = curHeapNode->next) {
        if (!curHeapNode->allocated) {
            curBlockLength = curHeapNode->length;
            if ((curBlockLength >= size) && (curBlockLength < smallestBlockFound || !smallestBlockFound)) {
                pPrevHeapNode = curHeapNode;
                smallestBlockFound = curBlockLength;
                nextHeapNode = curHeapNode->next;
            }
        }
        if (!curHeapNode->next) {
            break;
        }
    }
 
    // find out the required block size with header
    newBlockSize = size + sizeof(HeapNode);
 
    // if we found a block see if we need to split it up
    if (smallestBlockFound) {
        if (smallestBlockFound >= newBlockSize) {
            // update previous to the proper size for the block being returned
            pPrevHeapNode->next = (HeapNode*)((u8*)pPrevHeapNode + newBlockSize);
            pPrevHeapNode->length = size;
 
            // update the entry id on allocation
            HeapEntryID = heap_nextMallocID;
            pPrevHeapNode->allocated = TRUE;
            heap_nextMallocID = HeapEntryID + 1;
            pPrevHeapNode->entryID = HeapEntryID;
 
            // setup the new heap block entry
            curHeapNode = pPrevHeapNode->next;
            curHeapNode->next = nextHeapNode;
            curHeapNode->length = smallestBlockFound - newBlockSize;
            curHeapNode->allocated = FALSE;
        } else {
            // take this entry out of the free linked list and mark as allocated
            pPrevHeapNode->next = nextHeapNode;
            pPrevHeapNode->length = smallestBlockFound;
 
            // update the entry id on allocation
            // note, usage of a single ID from above will result in wrong code
            HeapEntryID2 = heap_nextMallocID;
            pPrevHeapNode->allocated = TRUE;
            heap_nextMallocID = HeapEntryID2 + 1;
            pPrevHeapNode->entryID = HeapEntryID2;
        }
        return (u8*)pPrevHeapNode + sizeof(HeapNode);
    }
    debug_printf("warning: out of memory\n");
    return NULL;
}

Referenced by _heap_realloc(), collision_heap_malloc(), general_heap_malloc(), heap_malloc(), imgfx_init(), spr_allocate_components(), spr_init_player_raster_cache(), spr_init_quad_cache(), and spr_load_sprite().

◆ _heap_malloc_tail()

void * _heap_malloc_tail	(	HeapNode *	head,
		u32	size )

Definition at line 152 of file 43F0.c.

                                                  {
    HeapNode* curNode;
    u32 newNodeSize;
    u32 foundNodeLength;
    HeapNode* foundNode;
    HeapNode* nextNode;
 
    size = ALIGN16(size);
    foundNode = NULL;
 
    // make sure we have a size to allocate
    if (!size) {
        debug_printf("warning: attempt to malloc less than 16 bytes\n");
        return NULL;
    }
 
    foundNodeLength = 0;
    nextNode = NULL;
 
    // find the smallest block we can fit into
    for (curNode = head; ; curNode = curNode->next) {
        if (!curNode->allocated) {
            if (curNode->length >= size) {
                foundNode = curNode;
                foundNodeLength = curNode->length;
                nextNode = curNode->next;
            }
        }
 
        if (!curNode->next) {
            break;
        }
    }
 
    newNodeSize = size + sizeof(HeapNode);
    if (foundNodeLength != 0) {
        curNode = foundNode;
 
        // we found a block to use, see if we can split it and return a portion
        // or if we just need to return the whole block
        if (foundNodeLength >= newNodeSize) {
            // add a free block before this one
            // this is where this function differs from heap_malloc, it returns
            // the end of the block instead of the beginning when splitting it up
            curNode->next = (HeapNode*)((u8*)curNode + foundNodeLength - size);
            curNode->length = foundNodeLength - newNodeSize;
            curNode->allocated = FALSE;
 
            curNode = curNode->next;
            curNode->next = nextNode;
            curNode->length = size;
            curNode->allocated = TRUE;
 
        } else {
            // just return this actual block
            curNode->next = nextNode;
            curNode->length = foundNodeLength;
            curNode->allocated = TRUE;
        }
 
        return (u8*)curNode + sizeof(HeapNode);
    }
 
    // did not find a block
    debug_printf("warning: out of memory\n");
    return NULL;
}

Referenced by general_heap_malloc_tail(), and spr_load_sprite().

◆ _heap_free()

u32 _heap_free	(	HeapNode *	heapNodeList,
		void *	addrToFree )

Definition at line 220 of file 43F0.c.

                                                         {
    u32 curNodeLength;
    HeapNode* nextNode;
    HeapNode* nodeToFreeHeader;
    HeapNode* tempNode;
    HeapNode* outNode;
 
    // if no address to free then return
    if (addrToFree == NULL) {
        return TRUE;
    }
 
    // if we are not allocated then ignore this request
    nodeToFreeHeader = (HeapNode*)((u8*)addrToFree - sizeof(HeapNode));
    if (!nodeToFreeHeader->allocated) {
        return TRUE;
    }
 
    nextNode = nodeToFreeHeader->next;
    curNodeLength = nodeToFreeHeader->length;
    outNode = nextNode;
 
    // see if the next node after us is allocated, if not then adjust our size
    // to include it and point nextNode to be the node after as it must be allocated
    if (nextNode && !nextNode->allocated) {
        curNodeLength += nextNode->length + sizeof(HeapNode);
        nextNode = nextNode->next;
    }
 
    // walk the full heap node list looking for the block before our current entry
    tempNode = heapNodeList;
    while (TRUE) {
        // get the pointer to the next block, if it matches the block being freed then
        // exit the search
        heapNodeList = tempNode->next;
        if (heapNodeList == nodeToFreeHeader) {
 
            // we found the node prior to us, if it is not allocated then adjust our total
            // size to include it and change the header node pointer to point that block
            if (!tempNode->allocated) {
                curNodeLength += sizeof(HeapNode) + tempNode->length;
                nodeToFreeHeader = tempNode;
            }
            break;
        }
 
        // if the node being freed is before the current node being looked at then we
        // moved past our current node, bail out. Also bail if we hit the end of the list
        if (nodeToFreeHeader < tempNode || !heapNodeList) {
            break;
        }
 
        // move to the next node
        tempNode = tempNode->next;
    }
 
    // update the node being free'd with a proper size and pointer to the next node that is
    // allocated
    outNode = nodeToFreeHeader;
    outNode->next = nextNode;
    outNode->length = curNodeLength;
    outNode->allocated = FALSE;
    return FALSE;
}

Referenced by _heap_realloc(), collision_heap_free(), general_heap_free(), heap_free(), and spr_free_sprite().

◆ _heap_realloc()

void * _heap_realloc	(	HeapNode *	heapNodeList,
		void *	addr,
		u32	newSize )

Definition at line 285 of file 43F0.c.

                                                                     {
    u32 newSizeAligned;
    HeapNode* nextNode;
    HeapNode* curHeapAlloc;
    HeapNode* newFreeBlock;
    u32 newNodeLength;
    HeapNode* nodeToUpdate;
 
    curHeapAlloc = (HeapNode*)((u8*)addr - sizeof(HeapNode));
    newSizeAligned = ALIGN16(newSize);
 
    // check if the realloc is on an allocated node otherwise fail
    if (!curHeapAlloc->allocated) {
        return NULL;
    }
 
    nextNode = curHeapAlloc->next;
    newNodeLength = curHeapAlloc->length;
 
    // if we have a node after us and it isn't allocated then
    // adjust the length and next node pointers to include the node after us
    nodeToUpdate = nextNode;
    if (nextNode && !nextNode->allocated) {
        nextNode = nextNode->next;
        newNodeLength += sizeof(HeapNode) + nodeToUpdate->length;
    }
 
    // check if the current block or current + next block (if free) are too small
    nodeToUpdate = curHeapAlloc;
    if (newNodeLength < newSizeAligned) {
        // too small, allocatr a new node, copy data to it then free the current one
        curHeapAlloc = _heap_malloc(heapNodeList, newSizeAligned);
        if (curHeapAlloc == NULL) {
            return NULL;
        }
 
        // minor interest note, copy the size of the newly allocated size
        // instead of just how much data used to be stored, this results in copying
        // excessive data
        memcpy(curHeapAlloc, addr, newSizeAligned);
        _heap_free(heapNodeList, addr);
        return curHeapAlloc;
    }
 
    // see if there is room to add a new free block after us
    if (newSizeAligned + sizeof(HeapNode) < newNodeLength) {
        // room for a free block, create it
        newFreeBlock = (HeapNode*)((u8*)addr + newSizeAligned);
 
        // update current node
        nodeToUpdate->next = newFreeBlock;
        nodeToUpdate->length = newSizeAligned;
 
        // create new node after the current one
        nodeToUpdate = newFreeBlock;
        nodeToUpdate->next = nextNode;
        nodeToUpdate->length = (newNodeLength - newSizeAligned) - sizeof(HeapNode);
        nodeToUpdate->allocated = FALSE;
    } else {
        // no room, update our next and length
        nodeToUpdate->next = nextNode;
        nodeToUpdate->length = newNodeLength;
    }
 
    // return the location we were at
    return addr;
}

Referenced by spr_load_npc_extra_anims().

◆ _heap_create()

HeapNode * _heap_create	(	HeapNode *	addr,
		u32	size )

Definition at line 63 of file 43F0.c.

                                                 {
    if (size < 32) {
        return (HeapNode*)-1;
    } else {
        HeapNode* heapNode = (HeapNode*)ALIGN16((u32)addr);
 
        size -= ((u8*)heapNode - (u8*)addr);
        heapNode->next = NULL;
        heapNode->length = size - sizeof(HeapNode);
        heapNode->allocated = 0;
        heapNode->capacity = size;
        return heapNode;
    }
}

Referenced by battle_heap_create(), battle_heap_create_obfuscated(), collision_heap_create(), general_heap_create(), and spr_init_sprites().

◆ dma_copy()

u32 dma_copy	(	Addr	romStart,
		Addr	romEnd,
		void *	vramDest )

Definition at line 443 of file 43F0.c.

                                                         {
    u32 length = romEnd - romStart;
    s32 i;
 
    osInvalICache(vramDest, length);
 
    for (i = 0; i + ROM_CHUNK_SIZE < length; i += ROM_CHUNK_SIZE) {
        nuPiReadRom((u32)romStart + i, vramDest + i, ROM_CHUNK_SIZE);
    }
 
    if (i != length) {
        nuPiReadRom((u32)romStart + i, vramDest + i, length - i);
    }
 
    return length;
}

Referenced by create_partner_npc(), dma_load_msg(), get_asset_offset(), imgfx_load_anim(), imgfx_mesh_anim_update(), load_asset_by_name(), load_battle_section(), load_effect(), load_font_data(), load_map_by_IDs(), load_obfuscation_shims(), load_simple_entity_data(), load_split_entity_data(), load_texture_by_name(), load_texture_impl(), load_texture_variants(), msg_copy_to_print_buffer(), phys_peach_update(), phys_update_action_state(), reload_world_entity_data(), state_init_logos(), state_step_end_battle(), state_step_unpause(), and use_consumable().

◆ rand_float()

f32 rand_float ( void )

Definition at line 503 of file 43F0.c.

                     {
    return (advance_rng() & 0x7FFF) / 32768.0;
}

Referenced by entity_shattering_init_pieces().

◆ copy_matrix()

void copy_matrix	(	Matrix4f	src,
		Matrix4f	dest )

Definition at line 438 of file 43F0.c.

                                              {
    bcopy(src, dest, sizeof(Matrix4f));
}

Referenced by animator_node_update_model_transform(), and update_collider_transform().

◆ get_shadow_by_index()

Shadow * get_shadow_by_index ( s32 index )

Definition at line 534 of file entity.c.

                                       {
    return (*gCurrentShadowListPtr)[index & 0xFFF];
}

Referenced by calculate_camera_yinterp_rate(), create_entity_shadow(), create_shadow_type(), delete_entity(), delete_entity_and_unload_data(), delete_shadow(), disable_npc_shadow(), disable_player_shadow(), enable_npc_shadow(), enable_player_shadow(), end_outta_sight_cleanup(), entity_base_block_update_slow_sinking(), entity_HitItemBlock_hide(), entity_HitItemBlock_show_inactive(), entity_ItemBlock_replace_with_inactive(), hide_item_entity(), make_item_entity(), make_item_entity_at_player(), npc_get_collider_below(), phys_is_on_sloped_ground(), render_shadows(), reveal_item_entity(), spawn_drops(), update_entity_shadow_position(), update_item_entities(), update_nonplayer_actor_shadow(), update_npcs(), update_player_actor_shadow(), update_player_shadow(), and update_shadows().

◆ get_time_freeze_mode()

s32 get_time_freeze_mode ( void )

Definition at line 390 of file main_loop.c.

                               {
    return gTimeFreezeMode;
}

Referenced by entity_Tweester_idle(), state_step_battle(), test_item_entity_position(), and test_item_player_collision().

◆ render_player_model()

void render_player_model ( void )

Definition at line 1495 of file 77480.c.

                               {
    RenderTask task;
    RenderTask* rtPtr = &task;
    PlayerStatus* playerStatus = &gPlayerStatus;
    s32 x, y, z;
 
    if (playerStatus->flags & PS_FLAG_SPRITE_REDRAW) {
        playerStatus->flags &= ~PS_FLAG_SPRITE_REDRAW;
        get_screen_coords(gCurrentCamID, playerStatus->pos.x, playerStatus->pos.y,
                          playerStatus->pos.z, &x, &y, &z);
        if (!(playerStatus->flags & PS_FLAG_SPINNING)) {
            if (playerStatus->curAlpha != playerStatus->prevAlpha) {
                if (playerStatus->curAlpha < 254) {
                    if (playerStatus->animFlags & PA_FLAG_MAP_HAS_SWITCH) {
                        playerStatus->renderMode = RENDER_MODE_SURFACE_XLU_LAYER2;
                    } else {
                        playerStatus->renderMode = RENDER_MODE_SURFACE_XLU_LAYER1;
                    }
                    set_player_imgfx_comp(PLAYER_SPRITE_MAIN, -1, IMGFX_SET_ALPHA, 0, 0, 0, playerStatus->curAlpha, 0);
 
                } else {
                    playerStatus->renderMode = RENDER_MODE_ALPHATEST;
                    set_player_imgfx_comp(PLAYER_SPRITE_MAIN, -1, IMGFX_CLEAR, 0, 0, 0, 0, 0);
                }
            }
 
            playerStatus->prevAlpha = playerStatus->curAlpha;
 
        } else {
            playerStatus->renderMode = RENDER_MODE_SURFACE_XLU_LAYER1;
            playerStatus->prevAlpha = 0;
        }
 
        if (!(playerStatus->animFlags & PA_FLAG_INVISIBLE)) {
            rtPtr->appendGfxArg = playerStatus;
            rtPtr->dist = -z;
            rtPtr->renderMode = playerStatus->renderMode;
 
            if (playerStatus->flags & PS_FLAG_SPINNING) {
                rtPtr->appendGfx = appendGfx_player_spin;
            } else {
                rtPtr->appendGfx = appendGfx_player;
            }
 
            queue_render_task(rtPtr);
        }
    }
}

Referenced by render_player().

◆ is_picking_up_item()

s32 is_picking_up_item ( void )

Returns: TRUE when "you got X" popup is on-screen

Definition at line 1554 of file item_entity.c.

                             {
#if VERSION_JP
    return isPickingUpItem;
#else
    b32 ret = D_801565A8 != FALSE;
 
    if (isPickingUpItem) {
        ret = TRUE;
    }
    return ret;
#endif
}

Referenced by can_open_world_menu(), check_conversation_trigger(), check_input_open_menus(), check_input_status_bar(), entity_Tweester_idle(), func_802BB000_E2D930(), and update_encounters_neutral().

◆ integrate_gravity()

f32 integrate_gravity ( void )

Definition at line 436 of file 7BB60.c.

                            {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    if (playerStatus->flags & PS_FLAG_ENTERING_BATTLE) {
        playerStatus->gravityIntegrator[2] += playerStatus->gravityIntegrator[3] / 1.7f;
        playerStatus->gravityIntegrator[1] += playerStatus->gravityIntegrator[2] / 1.7f;
        playerStatus->gravityIntegrator[0] += playerStatus->gravityIntegrator[1] / 1.7f;
    } else {
        #if DX_DEBUG_MENU
        if (dx_debug_is_cheat_enabled(DEBUG_CHEAT_HIGH_JUMP)) {
            playerStatus->gravityIntegrator[2] += playerStatus->gravityIntegrator[3];
            playerStatus->gravityIntegrator[1] += playerStatus->gravityIntegrator[2] * 1.5;
            playerStatus->gravityIntegrator[0] += playerStatus->gravityIntegrator[1] * 1.5;
            return playerStatus->gravityIntegrator[0];
        }
        #endif
 
        playerStatus->gravityIntegrator[2] += playerStatus->gravityIntegrator[3];
        playerStatus->gravityIntegrator[1] += playerStatus->gravityIntegrator[2];
        playerStatus->gravityIntegrator[0] += playerStatus->gravityIntegrator[1];
    }
 
    return playerStatus->gravityIntegrator[0];
}

Referenced by action_update_hit_fire(), action_update_knockback(), action_update_spin_jump(), action_update_step_up(), action_update_tornado_jump(), handle_jumping_land_on_switch(), phys_update_jump(), and player_fall_distance().

◆ gravity_use_fall_parms()

void gravity_use_fall_parms ( void )

Definition at line 302 of file 7BB60.c.

                                  {
    if (gPlayerStatus.flags & PS_FLAG_ENTERING_BATTLE) {
        gPlayerStatus.gravityIntegrator[0] = GravityParamsStartFall[0] / 12.0f;
        gPlayerStatus.gravityIntegrator[1] = GravityParamsStartFall[1] / 12.0f;
        gPlayerStatus.gravityIntegrator[2] = GravityParamsStartFall[2] / 12.0f;
        gPlayerStatus.gravityIntegrator[3] = GravityParamsStartFall[3] / 12.0f;
    } else {
        gPlayerStatus.gravityIntegrator[0] = GravityParamsStartFall[0];
        gPlayerStatus.gravityIntegrator[1] = GravityParamsStartFall[1];
        gPlayerStatus.gravityIntegrator[2] = GravityParamsStartFall[2];
        gPlayerStatus.gravityIntegrator[3] = GravityParamsStartFall[3];
    }
}

Referenced by action_update_state_23(), entity_TriggerBlock_disable_player_input(), handle_jumping_land_on_switch(), phys_main_collision_below(), and phys_update_jump().

◆ get_clamped_angle_diff()

f32 get_clamped_angle_diff	(	f32	a,
		f32	b )

Definition at line 605 of file 43F0.c.

                                         {
    if (fabsf(b - a) >= 180.0f) {
        if (b < a) {
            b += 360.0f;
        } else {
            b -= 360.0f;
        }
    }
    return b - a;
}

Referenced by AvoidPlayerAI_ChaseInit(), basic_ai_chase_init(), check_conversation_trigger(), CleftAI_CanSeePlayer(), FlyingAI_LosePlayer(), FlyingNoAttackAI_12(), GuardAI_ChaseInit(), MagikoopaAI_CanShootSpell(), MeleeHitbox_CanSeePlayer(), npc_do_player_collision(), npc_follow_npc(), npc_get_render_yaw(), partner_flying_follow_player(), partner_force_player_flip_done(), partner_walking_follow_player(), PatrolAI_ChaseInit(), player_get_side_angle(), player_update_sprite(), ProjectileHitbox_GetUsableProjectileID(), SentinelAI_ChaseInit(), set_npc_yaw(), test_item_player_collision(), update_camera_unused_radial(), update_encounters_neutral(), and update_unused_lead_amt().

◆ startup_fade_screen_in()

b32 startup_fade_screen_in ( s16 subtractAlpha )

Definition at line 13 of file startup_screen_fading.c.

                                              {
    if (gGameStatusPtr->screenColorA == 0) {
        return TRUE;
    }
 
    gGameStatusPtr->screenColorA -= subtractAlpha;
    if (gGameStatusPtr->screenColorA < 0) {
        gGameStatusPtr->screenColorA = 0;
    }
 
    return FALSE;
}

Referenced by state_step_logos(), and state_step_title_screen().

◆ startup_fade_screen_out()

b32 startup_fade_screen_out ( s16 addAlpha )

Definition at line 26 of file startup_screen_fading.c.

                                          {
    if (gGameStatusPtr->screenColorA == 255) {
        return TRUE;
    }
 
    gGameStatusPtr->screenColorA += addAlpha;
    if (gGameStatusPtr->screenColorA > 255) {
        gGameStatusPtr->screenColorA = 255;
    }
   
    return FALSE;
}

Referenced by state_step_intro(), state_step_logos(), and state_step_title_screen().

◆ startup_fade_screen_update()

void startup_fade_screen_update ( void )

Definition at line 39 of file startup_screen_fading.c.

                                      {
    set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, gGameStatusPtr->screenColorA);
    set_screen_overlay_color(SCREEN_LAYER_FRONT,
        gGameStatusPtr->screenColorR,
        gGameStatusPtr->screenColorG,
        gGameStatusPtr->screenColorB);
}

Referenced by state_init_intro(), state_init_logos(), state_init_title_screen(), state_step_demo(), state_step_intro(), state_step_logos(), and state_step_title_screen().

◆ get_entity_type()

u32 get_entity_type ( s32 arg0 )

Definition at line 568 of file entity.c.

                               {
    Entity* entity = get_entity_by_index(index);
 
    if (entity == NULL) {
        return -1;
    } else {
        return entity->blueprint->entityType;
    }
}

Referenced by action_hammer_test_swing_collision(), action_update_spin_jump(), action_update_tornado_jump(), can_dismount(), check_for_interactables(), collision_main_above(), entity_block_handle_collision(), entity_block_hit_animate_scale(), entity_block_hit_init_scale(), entity_breakable_block_create_shattering_entity(), entity_HitItemBlock_play_anim(), entity_ItemBlock_check_if_inactive(), entity_ItemBlock_replace_with_inactive(), entity_raycast_down(), entity_shattering_block_init(), entity_StarBoxLauncher_check_launch(), entity_try_partner_interaction_trigger(), func_800E06D8(), func_800EA4B0(), load_simple_entity_data(), load_split_entity_data(), phys_main_collision_below(), phys_player_land(), and should_continue_inspect().

◆ get_entity_by_index()

Entity * get_entity_by_index ( s32 index )

Definition at line 530 of file entity.c.

                                       {
    return (*gCurrentEntityListPtr)[index & 0xFFF];
}

Referenced by action_hammer_end_swing(), action_update_landing_on_switch(), action_update_spin_jump(), action_update_tornado_jump(), action_update_use_spinning_flower(), check_for_interactables(), check_input_jump(), delete_entity(), delete_entity_and_unload_data(), entity_ArrowSign_setupGfx(), entity_base_block_setupGfx(), entity_BlueWarpPipe_setupGfx(), Entity_BoardedFloor_setupGfx(), entity_BombableRock_setupGfx(), entity_Chest_setupGfx(), entity_HeartBlock_create_child_entity(), entity_HeartBlockContent__reset(), entity_HeartBlockContent__setupGfx(), entity_HeartBlockContent_anim_idle(), entity_HeartBlockContent_set_initial_pos(), entity_HiddenPanel_setupGfx(), entity_HitItemBlock_show_inactive(), entity_ItemBlock_replace_with_inactive(), entity_ItemBlock_setupGfx(), entity_MulticoinBlock_spawn_coin(), entity_Padlock_setupGfx(), entity_PinkFlower_idle(), entity_PinkFlower_init(), entity_PinkFlowerLight_idle(), entity_PinkFlowerLight_setupGfx(), entity_SaveBlock_setupGfx(), entity_shattering_setupGfx(), entity_SpinningFlower_setupGfx(), entity_StarBoxLauncher_setupGfx(), entity_SuperBlockContent_attach_to_parent(), entity_SuperBlockContent_setupGfx(), entity_try_partner_interaction_trigger(), entity_Tweester_render_face(), entity_Tweester_render_inner_whirl(), entity_Tweester_render_outer_whirl(), entity_Tweester_setupGfx(), entity_upgrade_block_check_if_inactive(), entity_upgrade_block_hide_content(), entity_WoodenCrate_setupGfx(), func_802BC050_E2E980(), get_entity_type(), interact_inspect_update(), npc_find_standing_on_entity(), phys_player_land(), player_raycast_down(), player_raycast_general(), player_raycast_up_corner(), render_entities(), test_ray_entities(), and update_entities().

◆ create_entity()

s32 create_entity	(	EntityBlueprint *	bp,
			... )

Definition at line 1195 of file entity.c.

                                            {
    va_list ap;
    f32 x, y, z;
    f32 rotY;
    s32 listIndex;
    Entity* entity;
    s32 idx;
 
    va_start(ap, bp);
 
    load_area_specific_entity_data();
 
    x = va_arg(ap, s32);
    y = va_arg(ap, s32);
    z = va_arg(ap, s32);
    rotY = va_arg(ap, s32);
 
    for (idx = 0; idx < ARRAY_COUNT(CreateEntityVarArgBuffer); idx++) {
        CreateEntityVarArgBuffer[idx] = 0;
    }
 
    for (idx = 0; idx < ARRAY_COUNT(CreateEntityVarArgBuffer); idx++) {
        s32 arg = va_arg(ap, s32);
 
        if (arg == MAKE_ENTITY_END) {
            break;
        }
        CreateEntityVarArgBuffer[idx] = arg;
    }
 
    va_end(ap);
 
    for (listIndex = 0; listIndex < ARRAY_COUNT(*gCurrentEntityListPtr); listIndex++) {
        if ((*gCurrentEntityListPtr)[listIndex] == NULL) {
            break;
        }
    }
 
    if (listIndex >= MAX_ENTITIES) {
        return -1;
    }
 
    (*gCurrentEntityListPtr)[listIndex] = entity = heap_malloc(sizeof(*entity));
    mem_clear(entity, sizeof(*entity));
    entity->dataBuf.any = NULL;
    if (bp->typeDataSize != 0) {
        entity->dataBuf.any = heap_malloc(bp->typeDataSize);
        mem_clear(entity->dataBuf.any, bp->typeDataSize);
    }
    entity->type = bp->entityType;
    entity->listIndex = listIndex;
    entity->boundScript = NULL;
    entity->updateMatrixOverride = NULL;
    entity->blueprint = bp;
    entity->scriptReadPos = bp->updateEntityScript;
    entity->scriptDelay = entity->scriptReadPos != NULL ? 1 : 0;
    entity->savedReadPos[0] = bp->updateEntityScript;
    entity->updateScriptCallback = NULL;
    entity->flags = bp->flags | ENTITY_FLAG_CREATED;
    entity->collisionFlags = 0;
    entity->collisionTimer = 0;
    entity->renderSetupFunc = NULL;
    entity->pos.x = x;
    entity->pos.y = y;
    entity->pos.z = z;
    entity->rot.x = 0.0f;
    entity->rot.y = rotY;
    entity->rot.z = 0.0f;
    entity->scale.x = 1.0f;
    entity->scale.y = 1.0f;
    entity->scale.z = 1.0f;
    entity->aabb.x = bp->aabbSize[0];
    entity->aabb.y = bp->aabbSize[1];
    entity->aabb.z = bp->aabbSize[2];
    entity->unk_05 = 1;
    entity->unk_08 = -1;
    entity->alpha = 255;
    entity->virtualModelIndex = -1;
    entity->shadowIndex = -1;
    entity->gfxBaseAddr = NULL;
 
    if (!(bp->flags & ENTITY_FLAG_HAS_ANIMATED_MODEL)) {
        if (bp->dma.start != 0) {
            load_simple_entity_data(entity, bp, listIndex);
        }
        if (bp->renderCommandList != NULL) {
            entity->virtualModelIndex = load_entity_model(bp->renderCommandList);
            exec_entity_model_commandlist(entity->virtualModelIndex);
        }
    } else {
        load_split_entity_data(entity, bp, listIndex);
    }
 
    if (bp->entityType != ENTITY_TYPE_SHADOW && (entity->flags & (ENTITY_FLAG_FIXED_SHADOW_SIZE | ENTITY_FLAG_HAS_SHADOW))) {
        create_entity_shadow(entity, x, y, z);
    }
 
    switch (bp->entityType) {
        case ENTITY_TYPE_BLUE_SWITCH:
        case ENTITY_TYPE_RED_SWITCH:
        case ENTITY_TYPE_SIMPLE_SPRING:
        case ENTITY_TYPE_SCRIPT_SPRING:
        case ENTITY_TYPE_STAR_BOX_LAUNCHER:
            entity->flags |= ENTITY_FLAG_4000;
            break;
    }
 
    if (bp->fpInit != NULL) {
        bp->fpInit(entity);
    }
 
    update_entity_transform_matrix(entity);
    return entity->listIndex;
}

Referenced by entity_breakable_block_create_shattering_entity(), entity_HeartBlock_create_child_entity(), entity_ItemBlock_check_if_inactive(), entity_ItemBlock_replace_with_inactive(), entity_MulticoinBlock_check_if_inactive(), entity_MulticoinBlock_idle(), entity_MulticoinBlock_spawn_coin(), entity_Munchlesia_create_child(), entity_PinkFlower_init(), and entity_upgrade_block_check_if_inactive().

◆ entity_shattering_idle()

void entity_shattering_idle ( Entity * entity )

Definition at line 63 of file ShatteringBlock_common.c.

                                            {
    ShatteringBlockData* data = entity->dataBuf.shatteringBlock;
    f32 rotSpeed = 0.0f;
    f32 reboundSpeed = 0.0f;
    f32 lateralSpeed = 0.0f;
    f32 angle;
    s32 i;
    f32 sinTheta;
    f32 cosTheta;
    f32 hitX, hitY, hitZ, hitDepth;
 
    for (i = 0; i < 24; i++) {
        switch (data->fragmentRebounds[i]) {
            case 0:
                if (data->fragmentFlags[i] & 1) {
                    lateralSpeed = 1.5f;
                } else {
                    lateralSpeed = 2.4f;
                }
                reboundSpeed = 6.0f;
                rotSpeed = data->fragmentRotSpeed[i];
                break;
            case 1:
                lateralSpeed = 1.2f;
                reboundSpeed = 3.0f;
                rotSpeed = data->fragmentRotSpeed[i] >> 2;
                break;
            case 2:
                lateralSpeed = 1.0f;
                reboundSpeed = 2.0f;
                rotSpeed = data->fragmentRotSpeed[i] >> 2;
                if (data->alpha == 0) {
                    data->fragmentRebounds[i]++;
                }
                break;
            case 3:
                data->fragmentPosY[i] -= 0.3;
                continue;
        }
 
        data->fragmentFallSpeed[i] -= 1.2;
        if (data->fragmentFallSpeed[i] < -12.2) {
            data->fragmentFallSpeed[i] = -12.2f;
        }
        data->fragmentPosY[i] += data->fragmentFallSpeed[i];
 
        angle = data->fragmentMoveAngle[i] * 360.0 / 256;
        sin_cos_rad(DEG_TO_RAD(angle), &sinTheta, &cosTheta);
        data->fragmentPosX[i] += lateralSpeed * sinTheta;
        data->fragmentPosZ[i] += lateralSpeed * cosTheta;
 
        hitX = data->fragmentPosX[i];
        hitY = data->fragmentPosY[i];
        hitZ = data->fragmentPosZ[i];
        if (npc_test_move_taller_with_slipping(COLLISION_IGNORE_ENTITIES, &hitX, &hitY, &hitZ, lateralSpeed, angle, 8.0f, 8.0f)) {
            data->fragmentPosX[i] = hitX;
            data->fragmentPosY[i] = hitY;
            data->fragmentPosZ[i] = hitZ;
            data->fragmentMoveAngle[i] += 0x80; // inverse yaw
 
            sin_cos_rad(DEG_TO_RAD(data->fragmentMoveAngle[i] * 360.0 / 256), &sinTheta, &cosTheta);
            lateralSpeed = 8.0f;
            data->fragmentPosX[i] += lateralSpeed * sinTheta;
            data->fragmentPosZ[i] += lateralSpeed * cosTheta;
        }
 
        hitX = data->fragmentPosX[i];
        hitY = data->fragmentPosY[i];
        hitZ = data->fragmentPosZ[i];
        hitDepth = fabsf(data->fragmentFallSpeed[i]);
        if (npc_raycast_down_sides(COLLISION_IGNORE_ENTITIES, &hitX, &hitY, &hitZ, &hitDepth) || hitY < data->originalPosY - 200.0f) {
            data->fragmentRebounds[i]++;
            data->fragmentPosY[i] = hitY + fabsf(data->fragmentFallSpeed[i]) * 1.2f;
            data->fragmentFallSpeed[i] = reboundSpeed;
        }
 
        data->fragmentRotX[i] += rotSpeed;
        data->fragmentRotY[i] -= rotSpeed;
    }
 
    data->fadeOutCounter++;
    if (data->fadeOutCounter >= 10) {
        data->fadeOutCounter = 10;
        data->alpha -= 8;
        if (data->alpha <= 0) {
            data->alpha = 0;
            exec_entity_commandlist(entity);
        }
    }
}

◆ show_damage_fx()

void show_damage_fx	(	Actor *	actor,
		f32	x,
		f32	y,
		f32	z,
		s32	damage )

Definition at line 2334 of file 190B20.c.

                                                                   {
    BattleStatus* battleStatus = &gBattleStatus;
    s32 intensity;
 
    if (damage < 3) {
        intensity = DAMAGE_INTENSITY_LIGHT;
    } else if (damage < 5) {
        intensity = DAMAGE_INTENSITY_MEDIUM;
    } else if (damage < 9) {
        intensity = DAMAGE_INTENSITY_HEAVY;
    } else {
        intensity = DAMAGE_INTENSITY_EXTREME;
    }
 
    if (battleStatus->curAttackElement & DAMAGE_TYPE_FIRE) {
        fx_ring_blast(0, x, y, z, 1.0f, 24);
    } else if (battleStatus->curAttackElement & DAMAGE_TYPE_SHOCK) {
        apply_shock_effect(actor);
    } else if (battleStatus->curAttackElement & DAMAGE_TYPE_WATER) {
        fx_water_splash(0, x, y, z, 1.0f, 24);
    } else {
        fx_firework(0, x, y, z, 1.0, intensity);
    }
}

Referenced by calc_enemy_damage_target(), calc_item_damage_enemy(), calc_partner_damage_enemy(), calc_player_damage_enemy(), dispatch_damage_event_actor(), dispatch_damage_event_partner(), and dispatch_damage_event_player().

◆ entity_raycast_down()

b32 entity_raycast_down	(	f32 *	x,
		f32 *	y,
		f32 *	z,
		f32 *	hitYaw,
		f32 *	hitPitch,
		f32 *	hitLength )

Mostly used for shadows.

Definition at line 1637 of file entity.c.

                                                                                            {
    f32 hitX, hitY, hitZ;
    f32 hitDepth;
    f32 hitNx, hitNy, hitNz;
    s32 entityID;
    s32 colliderID;
    s32 hitID;
 
    hitDepth = 32767.0f;
    hitID = NO_COLLIDER;
 
    entityID = test_ray_entities(*x, *y, *z, 0.0f, -1.0f, 0.0f, &hitX, &hitY, &hitZ, &hitDepth, &hitNx, &hitNy, &hitNz);
 
    if ((entityID > NO_COLLIDER) && ((get_entity_type(entityID) != ENTITY_TYPE_PUSH_BLOCK) || (hitNx == 0.0f && hitNz == 0.0f && hitNy == 1.0))) {
        hitID = entityID | COLLISION_WITH_ENTITY_BIT;
    }
 
    colliderID = test_ray_colliders(COLLIDER_FLAG_IGNORE_PLAYER, *x, *y, *z, 0.0f, -1.0f, 0.0f, &hitX, &hitY, &hitZ, &hitDepth, &hitNx,
                                    &hitNy, &hitNz);
    if (colliderID > NO_COLLIDER) {
        hitID = colliderID;
    }
 
    if (hitID > NO_COLLIDER) {
        *y = hitY;
        *hitLength = hitDepth;
        *hitYaw = -atan2(0.0f, 0.0f, hitNz * 100.0f, hitNy * 100.0f);
        *hitPitch = -atan2(0.0f, 0.0f, hitNx * 100.0f, hitNy * 100.0f);
        return TRUE;
    } else {
        *hitLength = 32767.0f;
        *hitYaw = 0.0f;
        *hitPitch = 0.0f;
        return FALSE;
    }
}

Referenced by entity_switch_fall_down(), is_block_on_ground(), update_entity_shadow_position(), and update_npcs().

◆ step_game_loop()

void step_game_loop ( void )

Definition at line 54 of file main_loop.c.

                          {
    profiler_frame_setup();
 
    PlayerData* playerData = &gPlayerData;
    const int MAX_GAME_TIME = 1000*60*60*60 - 1; // 1000 hours minus one frame at 60 fps
 
#if !VERSION_JP
    update_input();
    profiler_update(PROFILER_TIME_CONTROLLERS, 0);
#endif
 
    gGameStatusPtr->frameCounter++;
 
    playerData->frameCounter += 2;
    if (playerData->frameCounter > MAX_GAME_TIME) {
        playerData->frameCounter = MAX_GAME_TIME;
    }
 
#if VERSION_JP
    update_input();
    profiler_update(PROFILER_TIME_CONTROLLERS, 0);
#endif
 
    update_max_rumble_duration();
 
    if (gGameStepDelayCount != 0) {
        gGameStepDelayCount-- ;
        if (gGameStepDelayCount == 0) {
            gGameStepDelayCount = gGameStepDelayAmount;
        } else {
            return;
        }
    }
 
    mdl_reset_transform_flags();
    update_workers();
    profiler_update(PROFILER_TIME_WORKERS, 0);
    update_triggers();
    profiler_update(PROFILER_TIME_TRIGGERS, 0);
    update_scripts();
    profiler_update(PROFILER_TIME_EVT, 0);
    update_messages();
    profiler_update(PROFILER_TIME_MESSAGES, 0);
    update_hud_elements();
    profiler_update(PROFILER_TIME_HUD_ELEMENTS, 0);
    step_game_mode();
    profiler_update(PROFILER_TIME_STEP_GAME_MODE, 0);
    update_entities();
    profiler_update(PROFILER_TIME_ENTITIES, 0);
    func_80138198();
    bgm_update_music_settings();
    update_ambient_sounds();
    sfx_update_env_sound_params();
    update_windows();
    update_curtains();
 
    if (gOverrideFlags & GLOBAL_OVERRIDES_SOFT_RESET) {
        switch (SoftResetState) {
            case 0:
                gOverrideFlags |= GLOBAL_OVERRIDES_200;
                disable_player_input();
 
                if (SoftResetOverlayAlpha == 255) {
                    SoftResetState = 1;
                    SoftResetDelay = 3;
                } else {
                    SoftResetOverlayAlpha += 10;
                    if (SoftResetOverlayAlpha > 255) {
                        SoftResetOverlayAlpha = 255;
                    }
                }
                break;
            case 1:
                gOverrideFlags |= GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
                SoftResetDelay--;
                if (SoftResetDelay == 0) {
                    sfx_stop_env_sounds();
                    set_game_mode(GAME_MODE_STARTUP);
                    gOverrideFlags &= ~GLOBAL_OVERRIDES_SOFT_RESET;
                }
                break;
        }
    } else {
        SoftResetOverlayAlpha = 0;
        SoftResetState = 0;
    }
 
    if (gOverrideFlags & GLOBAL_OVERRIDES_DISABLE_BATTLES) {
        gOverrideFlags |= GLOBAL_OVERRIDES_PREV_DISABLE_BATTLES;
    } else {
        gOverrideFlags &= ~GLOBAL_OVERRIDES_PREV_DISABLE_BATTLES;
    }
 
    if (gOverrideFlags & GLOBAL_OVERRIDES_200) {
        gOverrideFlags |= GLOBAL_OVERRIDES_PREV_200;
    } else {
        gOverrideFlags &= ~GLOBAL_OVERRIDES_PREV_200;
    }
 
    if (gOverrideFlags & GLOBAL_OVERRIDES_400) {
        gOverrideFlags |= GLOBAL_OVERRIDES_PREV_400;
    } else {
        gOverrideFlags &= ~GLOBAL_OVERRIDES_PREV_400;
    }
 
    if (gOverrideFlags & GLOBAL_OVERRIDES_800) {
        gOverrideFlags |= GLOBAL_OVERRIDES_PREV_800;
    } else {
        gOverrideFlags &= ~GLOBAL_OVERRIDES_PREV_800;
    }
 
    // Unused rand_int used to advance the global random seed each visual frame
    rand_int(1);
}

Referenced by gfxRetrace_Callback().

◆ resume_all_group()

s32 resume_all_group ( s32 groupFlags )

Definition at line 858 of file script_list.c.

                                     {
    s32 i;
    Evt* scriptContextPtr;
 
    for (i = 0; i < MAX_SCRIPTS; i++) {
        scriptContextPtr = (*gCurrentScriptListPtr)[i];
        if (scriptContextPtr != NULL) {
            resume_group_script(scriptContextPtr, groupFlags);
        }
    }
}

Referenced by create_encounters(), evt_handle_resume_all(), set_time_freeze_mode(), start_battle(), update_encounters_conversation(), update_encounters_post_battle(), and update_item_entity_collectable().

◆ length2D()

f32 length2D	(	f32	x,
		f32	y )

Definition at line 59 of file 43F0.c.

                           {
    return sqrtf(SQ(x) + SQ(y));
}

Referenced by ArcsinDeg().

◆ player_input_to_move_vector()

void player_input_to_move_vector	(	f32 *	angle,
		f32 *	magnitude )

Definition at line 140 of file 7B440.c.

                                                                   {
    PlayerStatus* playerStatus = &gPlayerStatus;
    f32 stickAxisX = playerStatus->stickAxis[0];
    f32 stickAxisY = -playerStatus->stickAxis[1];
    f32 maxRadius = 70.0f;
    f32 magnitude;
    f32 angle;
 
    magnitude = dist2D(0.0f, 0.0f, stickAxisX, stickAxisY);
    if (magnitude >= maxRadius) {
        magnitude = maxRadius;
    }
 
    angle = clamp_angle(atan2(0.0f, 0.0f, stickAxisX, stickAxisY) + gCameras[CAM_DEFAULT].curYaw);
    if (magnitude == 0.0f) {
        angle = playerStatus->targetYaw;
    }
 
    *outAngle = angle;
    *outMagnitude = magnitude;
}

Referenced by action_update_idle(), action_update_idle_peach(), action_update_land(), action_update_peach_land(), action_update_peach_step_down_land(), action_update_pushing_block(), action_update_run(), action_update_spin(), action_update_step_down_land(), action_update_walk(), collision_main_above(), collision_main_lateral(), and phys_player_land().

◆ game_input_to_move_vector()

void game_input_to_move_vector	(	f32 *	x,
		f32 *	y )

Definition at line 162 of file 7B440.c.

                                                                 {
    f32 stickX = gGameStatusPtr->stickX[0];
    f32 stickY = -gGameStatusPtr->stickY[0];
    f32 maxRadius = 70.0f;
    f32 magnitude;
    f32 angle;
 
    magnitude = dist2D(0.0f, 0.0f, stickX, stickY);
    if (magnitude >= maxRadius) {
        magnitude = maxRadius;
    }
 
    angle = clamp_angle(atan2(0.0f, 0.0f, stickX, stickY) + gCameras[CAM_DEFAULT].curYaw);
    if (magnitude == 0.0f) {
        angle = gPlayerStatus.targetYaw;
    }
 
    *outAngle = angle;
    *outMagnitude = magnitude;
}

Referenced by action_update_use_spinning_flower().

◆ exec_ShakeCamX()

void exec_ShakeCamX	(	s32	arg0,
		s32	arg1,
		s32	arg2,
		f32	arg3 )

Definition at line 374 of file cam_api.c.

                                                                      {
    Evt* script;
 
    script = start_script_in_group(&ShakeCamX, EVT_PRIORITY_1, 0, EVT_GROUP_SHAKE_CAM);
    evt_set_variable(script, LVar0, camID);
    evt_set_variable(script, LVar1, mode);
    evt_set_variable(script, LVar2, duration);
    evt_set_float_variable(script, LVar3, magnitude);
}

Referenced by action_hammer_play_hit_fx(), action_update_hit_lava(), and entity_HiddenPanel_flip_over().

◆ exec_ShakeCam1()

void exec_ShakeCam1	(	s32	arg0,
		s32	arg1,
		s32	arg2 )

Definition at line 365 of file cam_api.c.

                                                       {
    Evt* script;
 
    script = start_script_in_group(&ShakeCam1, EVT_PRIORITY_1, 0, EVT_GROUP_SHAKE_CAM);
    script->varTable[0] = camID;
    script->varTable[1] = mode;
    script->varTable[2] = duration;
}

Referenced by action_update_spin_jump(), action_update_tornado_jump(), and get_overriding_player_anim().

◆ player_get_side_angle()

f32 player_get_side_angle ( void )

Definition at line 1178 of file 7BB60.c.

                                {
    f32 deltaYaw = get_clamped_angle_diff(gCameras[gCurrentCameraID].curYaw, gPlayerStatus.curYaw);
 
    if (deltaYaw < -5.0f && deltaYaw > -175.0f) {
        deltaYaw = 0.0f;
    } else if (deltaYaw > 5.0f && deltaYaw < 175.0f) {
        deltaYaw = 180.0f;
    } else {
        deltaYaw = PrevPlayerCamRelativeYaw;
    }
    return clamp_angle(deltaYaw - 90.0f + gCameras[gCurrentCameraID].curYaw);
}

Referenced by action_hammer_end_swing(), action_hammer_play_hit_fx(), action_hammer_test_swing_collision(), entity_StarBoxLauncher_check_launch(), parasol_get_npc(), partner_flying_follow_player(), and partner_walking_follow_player().

◆ draw_number()

void draw_number	(	s32	value,
		s32	x,
		s32	y,
		s32	variableWidthChars,
		s32	palette,
		s32	opacity,
		u16	style )

Definition at line 2223 of file msg.c.

                                                                                            {
    u8 valueStr[24];
    s8 digits[24];
    s32 digitPosX[24];
    s32 i;
    s32 count;
    s32 posX;
    IMG_PTR raster = gMsgNumbers[charset].rasters;
    s32 texSize = gMsgNumbers[charset].texSize;
 
#if !VERSION_JP
    y -= 2;
#endif
    if (y < 0 || y > 240) {
        return;
    }
 
    int_to_string(value, valueStr, 10);
 
    for (i = 0; i < 10; i++) {
        u8 digit;
        if (valueStr[i] == '\0') {
            break;
        }
 
        // handle negative numbers
        if (valueStr[i] == '-') {
            digits[i] = MSG_CHAR_MINUS - MSG_CHAR_DIGIT_0;
            continue;
        }
 
        digit = valueStr[i] - '0';
        if (digit < 10){
            digits[i] = digit;
        }
    }
    posX = x;
    count = i;
 
    gSPDisplayList(gMainGfxPos++, gMsgDlistInitDrawNumber);
 
    if (style & DRAW_NUMBER_STYLE_ALIGN_RIGHT) {
        for (i = count - 1; i >= 0; i--) {
            if ((style & DRAW_NUMBER_STYLE_MONOSPACE) || digits[i] < 0) {
                posX -= gMsgNumbers[charset].fixedWidth;
            } else {
                posX -= gMsgNumbers[charset].digitWidth[digits[i]];
            }
            digitPosX[i] = posX;
        }
    } else {
        for (i = 0; i < count; i++) {
            digitPosX[i] = posX;
            if ((style & DRAW_NUMBER_STYLE_MONOSPACE) || digits[i] < 0) {
                posX += gMsgNumbers[charset].fixedWidth;
            } else {
                posX += gMsgNumbers[charset].digitWidth[digits[i]];
            }
        }
    }
 
    if (style & DRAW_NUMBER_STYLE_DROP_SHADOW) {
        for (i = 0; i < count; i++) {
            gDPPipeSync(gMainGfxPos++);
            gDPSetRenderMode(gMainGfxPos++, G_RM_XLU_SURF, G_RM_XLU_SURF2);
            gDPSetCombineMode(gMainGfxPos++, PM_CC_07, PM_CC_07);
            gDPSetPrimColor(gMainGfxPos++, 0, 0, 40, 40, 40, 72);
            draw_digit(raster + digits[i] * texSize, charset, digitPosX[i] + 2, y + 2);
            gDPPipeSync(gMainGfxPos++);
        }
    }
 
    if (opacity == 255) {
        gDPSetRenderMode(gMainGfxPos++, G_RM_TEX_EDGE, G_RM_TEX_EDGE2);
        gDPSetCombineMode(gMainGfxPos++, G_CC_DECALRGBA, G_CC_DECALRGBA);
    } else {
        gDPSetRenderMode(gMainGfxPos++, G_RM_XLU_SURF, G_RM_XLU_SURF2);
        gDPSetCombineMode(gMainGfxPos++, PM_CC_01, PM_CC_01);
        gDPSetPrimColor(gMainGfxPos++, 0, 0, 255, 255, 255, opacity);
    }
 
    gDPLoadTLUT_pal16(gMainGfxPos++, 0, D_802F4560[palette]);
    for (i = 0; i < count; i++) {
        posX = digitPosX[i];
        if (posX > 0 && posX < 320) {
            draw_digit(raster + digits[i] * texSize, charset, posX, y);
        }
    }
    gDPPipeSync(gMainGfxPos++);
}

Referenced by btl_menu_moves_draw_content(), coin_counter_draw_content(), draw_shop_items(), filemenu_draw_contents_file_info(), filemenu_draw_contents_file_title(), filemenu_info_draw_message_contents(), filemenu_yesno_draw_prompt_contents(), func_800F4D28(), pause_badges_draw_contents(), pause_partners_draw_movelist(), pause_stats_draw_contents(), popup_menu_draw_menu_contents(), and popup_menu_draw_title_contents().

◆ set_entity_model_flags()

void set_entity_model_flags	(	s32	idx,
		s32	newFlags )

Definition at line 758 of file entity_model.c.

                                                   {
    EntityModel* entityModel = (*gCurrentEntityModelList)[idx & ~BATTLE_ENTITY_ID_BIT];
 
    if (entityModel != NULL && entityModel->flags) {
        entityModel->flags |= newFlags;
    }
}

Referenced by show_immune_bonk().

◆ clear_entity_model_flags()

void clear_entity_model_flags	(	s32	idx,
		s32	newFlags )

Definition at line 766 of file entity_model.c.

                                                     {
    EntityModel* entityModel = (*gCurrentEntityModelList)[idx & ~BATTLE_ENTITY_ID_BIT];
 
    if (entityModel != NULL && entityModel->flags) {
        entityModel->flags &= ~newFlags;
    }
}

Referenced by btl_bonk_update().

◆ exec_entity_model_commandlist()

void exec_entity_model_commandlist ( s32 idx )

Definition at line 172 of file entity_model.c.

                                            {
    EntityModel* entityModel;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD || (idx & BATTLE_ENTITY_ID_BIT)) {
        idx &= ~BATTLE_ENTITY_ID_BIT;
        entityModel = (*gCurrentEntityModelList)[idx];
        if (entityModel != NULL && (entityModel->flags)) {
            if (!(entityModel->flags & ENTITY_MODEL_FLAG_HIDDEN)) {
                if (!(entityModel->flags & ENTITY_MODEL_FLAG_DISABLE_SCRIPT)) {
                    entityModel->flags &= ~ENTITY_MODEL_FLAG_100;
                    entityModel->nextFrameTime -= entityModel->timeScale;
                    if (entityModel->nextFrameTime <= 0.0f) {
                        while (step_entity_model_commandlist(entityModel));
                    }
                }
            }
        }
    }
}

Referenced by ALT_virtual_entity_create(), btl_bonk_update(), create_entity(), update_entities(), update_shadows(), virtual_entity_create(), virtual_entity_create_at_index(), and virtual_entity_list_update().

◆ queue_render_task()

RenderTask * queue_render_task ( RenderTask * task )

Definition at line 4546 of file model.c.

                                                {
    s32 dist = RenderTaskBasePriorities[task->renderMode] - task->dist;
    s32 listIdx = RENDER_TASK_LIST_MID;
    if (dist >= 3000000) listIdx = RENDER_TASK_LIST_FAR;
    else if (dist < 800000) listIdx = RENDER_TASK_LIST_NEAR;
 
    RenderTask* ret = RenderTaskLists[listIdx];
 
    ASSERT(RenderTaskCount[listIdx] < ARRAY_COUNT(*ClearRenderTaskLists));
 
    ret = &ret[RenderTaskCount[listIdx]++];
 
    ret->renderMode = RENDER_TASK_FLAG_ENABLED;
    if (task->renderMode == RENDER_MODE_CLOUD_NO_ZCMP) {
        ret->renderMode |= RENDER_TASK_FLAG_20;
    }
 
    ret->appendGfxArg = task->appendGfxArg;
    ret->appendGfx = task->appendGfx;
    ret->dist = dist;
 
    return ret;
}

◆ create_mesh_animator()

s32 create_mesh_animator	(	s16 *	animPos,
		s16 *	animBuffer )

Definition at line 366 of file animator.c.

                                                        {
    ModelAnimator* animator;
    s32 i, j;
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentAnimMeshListPtr); i++) {
        if ((*gCurrentAnimMeshListPtr)[i] == NULL) {
            break;
        }
    }
 
    ASSERT(i < ARRAY_COUNT(*gCurrentAnimMeshListPtr));
 
    (*gCurrentAnimMeshListPtr)[i] = animator = heap_malloc(sizeof(*animator));
    gAnimCount++;
 
    ASSERT(animator != NULL);
 
    animator->flags = MODEL_ANIMATOR_FLAG_UPDATE_PENDING | MODEL_ANIMATOR_FLAG_ENABLED | MODEL_ANIMATOR_FLAG_CAM_2 | MODEL_ANIMATOR_FLAG_CAM_1 | MODEL_ANIMATOR_FLAG_CAM_0;
    animator->renderMode = RENDER_MODE_ALPHATEST;
    animator->baseAddr = NULL;
    animator->fpRenderCallback = NULL;
    animator->rootNode = NULL;
    animator->nextUniqueID = 0;
    animator->animationBuffer = animBuffer;
    animator->nextUpdateTime = 1.0f;
    animator->timeScale = 1.0f;
    animPos = (s16*)(((s32)animPos & 0xFFFFFF) + (s32)animator->animationBuffer);
    animator->animReadPos = animPos;
    animator->savedReadPos = animPos;
 
    for (j = 0; j < ARRAY_COUNT(animator->nodeCache); j++) {
        animator->nodeCache[j] = NULL;
    }
 
    for (j = 0; j < ARRAY_COUNT(animator->staticNodeIDs); j++) {
        animator->staticNodeIDs[j] = j + 1;
    }
 
    if (gGameStatusPtr->context != CONTEXT_WORLD) {
        i |= BATTLE_ID_BIT;
    }
    return i;
}

Referenced by load_split_entity_data().

◆ load_mesh_animator_tree()

void load_mesh_animator_tree	(	s32	index,
		StaticAnimatorNode **	tree )

Definition at line 1198 of file animator.c.

                                                                   {
    s32 indexMasked = index & ~BATTLE_ID_BIT;
    ModelAnimator* animator = (*gCurrentAnimMeshListPtr)[indexMasked];
    s32 nodeIDs[ARRAY_COUNT(animator->staticNodeIDs)];
    s32 i;
 
    if (animator == NULL || animator->flags == 0) {
        return;
    }
 
    if ((*tree)->vertexStartOffset == 0) {
        load_model_animator_tree(indexMasked, tree);
        return;
    }
 
    gAnimTreeRoot = tree;
    animator->staticRoot = tree;
    animator->treeIndexPos = 0;
    animator->savedTreePos = 0;
 
    for (i = 0; i < ARRAY_COUNT(animator->staticNodes); i++) {
        animator->staticNodes[i] = NULL;
    }
 
    load_mesh_animator_node(*gAnimTreeRoot, animator, 0, nodeIDs);
    animator->flags |= MODEL_ANIMATOR_FLAG_MESH;
}

Referenced by load_split_entity_data().

◆ setup_pause_menu_tab()

void setup_pause_menu_tab	(	MenuWindowBP *	bpArray,
		s32	arraySize )

Definition at line 461 of file windows.c.

                                                       {
    s32 i;
 
    for (i = 0; i < count; i++) {
        set_window_properties(bp->windowID, bp->pos.x, bp->pos.y, bp->width, bp->height, bp->priority,
                              bp->fpDrawContents, bp->tab, bp->parentID);
        if (bp->style.defaultStyleID != -1) {
            gWindowStyles[bp->windowID] = bp->style;
        }
        set_window_update(bp->windowID, bp->fpUpdate.i);
        gWindows[bp->windowID].flags |= bp->extraFlags;
        bp++;
    }
}

Referenced by filemenu_choose_name_init(), filemenu_info_init(), filemenu_init(), filemenu_main_init(), filemenu_yesno_init(), pause_badges_init(), pause_init(), pause_items_init(), pause_map_init(), pause_partners_init(), pause_spirits_init(), pause_stats_init(), and pause_tabs_init().

◆ draw_ci_image_with_clipping()

s32 draw_ci_image_with_clipping	(	u8 *	raster,
		s32	width,
		s32	height,
		s32	fmt,
		s32	bitDepth,
		u16 *	palette,
		s16	posX,
		s16	posY,
		u16	clipULx,
		u16	clipULy,
		u16	clipLRx,
		u16	clipRLy,
		u8	opacity )

Referenced by appendGfx_message(), msg_draw_choice_pointer(), and msg_draw_rewind_arrow().

◆ render_frame()

void render_frame ( s32 flag )

Definition at line 91 of file cam_main.c.

                                    {
    s32 firstCamID;
    s32 lastCamID;
    s32 camID;
 
    if (!isSecondPass) {
        gCurrentCamID = CAM_DEFAULT;
        mdl_update_transform_matrices();
    }
 
    // first pass:  loop uses camIDs from CAM_DEFAULT to CAM_HUD - 1
    // second pass: loop only uses CAM_HUD
    if (isSecondPass) {
        firstCamID = CAM_HUD;
        lastCamID = ARRAY_COUNT(gCameras);
    } else {
        firstCamID = CAM_DEFAULT;
        lastCamID = CAM_HUD;
    }
 
    for (camID = firstCamID; camID < lastCamID; camID++) {
        Camera* camera = &gCameras[camID];
 
        if (camera->flags == 0 || (camera->flags & (CAMERA_FLAG_NO_DRAW | CAMERA_FLAG_DISABLED))) {
            continue;
        }
 
        gCurrentCamID = camID;
 
        if (camera->fpDoPreRender != NULL) {
            camera->fpDoPreRender(camera);
        } else {
            s32 ulx;
            s32 uly;
            s32 lrx;
            s32 lry;
 
            gSPViewport(gMainGfxPos++, &camera->vp);
            gSPClearGeometryMode(gMainGfxPos++, G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN |
                                    G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH);
            gSPTexture(gMainGfxPos++, 0, 0, 0, G_TX_RENDERTILE, G_OFF);
            gDPSetCycleType(gMainGfxPos++, G_CYC_1CYCLE);
            gDPPipelineMode(gMainGfxPos++, G_PM_NPRIMITIVE);
 
            ulx = camera->viewportStartX;
            uly = camera->viewportStartY;
            lrx = ulx + camera->viewportW;
            lry = uly + camera->viewportH;
 
            if (ulx < 0) {
                ulx = 0;
            }
            if (uly < 0) {
                uly = 0;
            }
            if (lrx < 1) {
                lrx = 1;
            }
            if (lry < 1) {
                lry = 1;
            }
 
            if (ulx > SCREEN_WIDTH - 1) {
                ulx = SCREEN_WIDTH - 1;
            }
            if (uly > SCREEN_HEIGHT - 1) {
                uly = SCREEN_HEIGHT - 1;
            }
            if (lrx > SCREEN_WIDTH) {
                lrx = SCREEN_WIDTH;
            }
            if (lry > SCREEN_HEIGHT) {
                lry = SCREEN_HEIGHT;
            }
 
            gDPSetScissor(gMainGfxPos++, G_SC_NON_INTERLACE, ulx, uly, lrx, lry);
            gDPSetTextureLOD(gMainGfxPos++, G_TL_TILE);
            gDPSetTextureLUT(gMainGfxPos++, G_TT_NONE);
            gDPSetTextureDetail(gMainGfxPos++, G_TD_CLAMP);
            gDPSetTexturePersp(gMainGfxPos++, G_TP_PERSP);
            gDPSetTextureFilter(gMainGfxPos++, G_TF_BILERP);
            gDPSetTextureConvert(gMainGfxPos++, G_TC_FILT);
            gDPSetCombineMode(gMainGfxPos++, G_CC_SHADE, G_CC_SHADE);
            gDPSetCombineKey(gMainGfxPos++, G_CK_NONE);
            gDPSetAlphaCompare(gMainGfxPos++, G_AC_NONE);
            gDPSetRenderMode(gMainGfxPos++, G_RM_OPA_SURF, G_RM_OPA_SURF2);
            gDPSetColorDither(gMainGfxPos++, G_CD_DISABLE);
            gSPClipRatio(gMainGfxPos++, FRUSTRATIO_2);
            gDPSetColorImage(gMainGfxPos++, G_IM_FMT_RGBA, G_IM_SIZ_16b, SCREEN_WIDTH,
                                osVirtualToPhysical(nuGfxCfb_ptr));
            gDPPipeSync(gMainGfxPos++);
 
            if (!(camera->flags & CAMERA_FLAG_ORTHO)) {
                gSPPerspNormalize(gMainGfxPos++, camera->perspNorm);
            }
 
            guMtxF2L(camera->mtxPerspective, &gDisplayContext->camPerspMatrix[gCurrentCamID]);
            gSPMatrix(gMainGfxPos++, &gDisplayContext->camPerspMatrix[gCurrentCamID], G_MTX_NOPUSH | G_MTX_LOAD |
                        G_MTX_PROJECTION);
        }
 
        camera->mtxBillboard = &gDisplayContext->matrixStack[gMatrixListPos++];
        guRotate(camera->mtxBillboard, -camera->curBoomYaw, 0.0f, 1.0f, 0.0f);
 
        camera->vpAlt.vp.vtrans[0] = camera->vp.vp.vtrans[0] + gGameStatusPtr->altViewportOffset.x;
        camera->vpAlt.vp.vtrans[1] = camera->vp.vp.vtrans[1] + gGameStatusPtr->altViewportOffset.y;
 
        if (!(camera->flags & CAMERA_FLAG_ORTHO)) {
            if (gCurrentCamID != CAM_HUD) {
                if (!(camera->flags & CAMERA_FLAG_RENDER_ENTITIES)) {
                    GFX_PROFILER_START(PROFILER_TIME_SUB_GFX_ENTITIES);
                    render_entities();
                    GFX_PROFILER_COMPLETE(PROFILER_TIME_SUB_GFX_ENTITIES);
                }
                if (!(camera->flags & CAMERA_FLAG_RENDER_MODELS)) {
                    GFX_PROFILER_START(PROFILER_TIME_SUB_GFX_MODELS);
                    #if DX_DEBUG_MENU
                    if (!dx_debug_should_hide_models()) {
                        render_models();
                    }
                    #else
                    render_models();
                    #endif
                    GFX_PROFILER_COMPLETE(PROFILER_TIME_SUB_GFX_MODELS);
                }
                GFX_PROFILER_START(PROFILER_TIME_SUB_GFX_PLAYER);
                render_player();
                GFX_PROFILER_SWITCH(PROFILER_TIME_SUB_GFX_PLAYER, PROFILER_TIME_SUB_GFX_NPCS);
                render_npcs();
                GFX_PROFILER_SWITCH(PROFILER_TIME_SUB_GFX_NPCS, PROFILER_TIME_SUB_GFX_WORKERS);
                render_workers_scene();
                GFX_PROFILER_SWITCH(PROFILER_TIME_SUB_GFX_WORKERS, PROFILER_TIME_SUB_GFX_EFFECTS);
                render_effects_scene();
                GFX_PROFILER_SWITCH(PROFILER_TIME_SUB_GFX_EFFECTS, PROFILER_TIME_SUB_GFX_RENDER_TASKS);
                execute_render_tasks();
                #if DX_DEBUG_MENU
                dx_debug_draw_collision();
                #endif
                GFX_PROFILER_SWITCH(PROFILER_TIME_SUB_GFX_RENDER_TASKS, PROFILER_TIME_SUB_GFX_HUD_ELEMENTS);
                render_transformed_hud_elements();
            } else {
                guOrthoF(camera->mtxPerspective, 0.0f, SCREEN_WIDTH, -SCREEN_HEIGHT, 0.0f, -1000.0f, 1000.0f, 1.0f);
                guMtxF2L(camera->mtxPerspective, &gDisplayContext->camPerspMatrix[gCurrentCamID]);
                gSPMatrix(gMainGfxPos++, &gDisplayContext->camPerspMatrix[gCurrentCamID], G_MTX_NOPUSH |
                            G_MTX_LOAD | G_MTX_PROJECTION);
                render_transformed_hud_elements();
                render_item_entities();
            }
        } else {
            render_workers_scene();
            execute_render_tasks();
        }
 
        if (camera->fpDoPostRender != NULL) {
            camera->fpDoPostRender(camera);
        }
 
        gDPPipeSync(gMainGfxPos++);
        gDPSetColorImage(gMainGfxPos++, G_IM_FMT_RGBA, G_IM_SIZ_16b, SCREEN_WIDTH,
                            osVirtualToPhysical(nuGfxCfb_ptr));
        gDPPipeSync(gMainGfxPos++);
    }
}

Referenced by appendGfx_title_screen(), and gfx_draw_frame().

◆ clear_windows()

void clear_windows ( void )

Definition at line 135 of file windows.c.

                         {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gWindows); i++) {
        gWindows[i].flags = 0;
    }
}

Referenced by load_engine_data(), state_step_startup(), and state_step_title_screen().

◆ update_window_hierarchy()

void update_window_hierarchy	(	s32	windowIndex,
		u8	arg1 )

Definition at line 393 of file windows.c.

                                                        {
    s32 priorityArray[ARRAY_COUNT(gWindows) + 1];
    s32 curPriority;
    s32 i;
 
    if (priority > ARRAY_COUNT(gWindows)) {
        priority = ARRAY_COUNT(gWindows);
    }
 
    for (i = 0; i < ARRAY_COUNT(priorityArray); i++) {
        priorityArray[i] = -1;
    }
    priorityArray[priority] = windowID;
 
    for (i = 0; i < ARRAY_COUNT(gWindows); i++) {
        if (gWindows[i].flags && i != windowID) {
            curPriority = gWindows[i].priority;
            if (curPriority >= priority) {
                curPriority++;
            }
            priorityArray[curPriority] = i;
        }
    }
 
    curPriority = 0;
    for (i = 0; i < ARRAY_COUNT(priorityArray); i++) {
        s32 windowIdx = priorityArray[i];
        if (windowIdx != WIN_NONE) {
            gWindows[windowIdx].priority = curPriority++;
        }
    }
}

Referenced by filemenu_init(), pause_init(), pause_update_tab_active(), pause_update_tab_inactive(), render_windows(), and set_window_properties().

◆ get_msg_properties()

void get_msg_properties	(	s32	msgID,
		s32 *	height,
		s32 *	width,
		s32 *	maxLineChars,
		s32 *	numLines,
		s32 *	maxLinesPerPage,
		s32 *	arg6,
		u16	charset )

Definition at line 1671 of file msg.c.

                                                                                                                                                 {
    u8* message;
    s32 i;
    u16 pageCount;
    s32 linesOnPage;
    u8 stop;
    s32 lineWidth;
    s32 charCount;
    u16 lineIndex;
    s32 msgStyle;
    s32 functionCode;
    u8 packedScaleY;
    f32 scale;
    s32 temp;
 
    u16 lineWidths[32];
    u16 lineCharNumbers[32];
    u16 linesPerPage[32];
    s32 lineCount;
    u16 varIndex;
    u16 font;
    u8* buffer;
    u16 maxLineWidth;
    u16 maxCharsPerLine;
    u16 maxLinesOnPage;
    u16 spaceCount;
    u16 endl;
 
    u8 c;
    u8 prevChar;
 
    scale = 1.0f;
    c = 0;
    lineIndex = 0;
    pageCount = 0;
    varIndex = 0;
    font = 0;
    buffer = NULL;
    maxLineWidth = 0;
    maxCharsPerLine = 0;
    maxLinesOnPage = 0;
    spaceCount = 0;
 
    if (msgID == MSG_NONE) {
        return;
    }
 
    if (msgID >= 0) {
        buffer = general_heap_malloc(0x400);
        dma_load_msg(msgID, buffer);
        message = buffer;
    } else {
        message = (u8*)msgID;
    }
 
    if (charset & 1) {
        font = 1;
    }
 
    i = 0;
    stop = FALSE;
    lineWidth = 0;
    linesOnPage = 0;
    charCount = 0;
    endl = TRUE;
    lineCount = 0;
 
    do {
        prevChar = c;
        c = message[i++];
        switch (c) {
            case MSG_CHAR_READ_VARIANT0:
            case MSG_CHAR_READ_VARIANT1:
            case MSG_CHAR_READ_VARIANT2:
            case MSG_CHAR_READ_VARIANT3:
                varIndex = c - MSG_CHAR_READ_VARIANT0;
                break;
            case MSG_CHAR_READ_PAUSE:
                i++;
                break;
            case MSG_CHAR_READ_WAIT:
            case MSG_CHAR_READ_NEXT:
                if (linesOnPage != 0) {
                    linesPerPage[pageCount] = linesOnPage;
                    pageCount++;
                    if (pageCount >= 32) {
                        stop = 1;
                    }
                    linesOnPage = 0;
                }
                break;
            case MSG_CHAR_READ_ENDL:
                lineWidths[lineIndex] = lineWidth;
                lineCharNumbers[lineIndex] = charCount;
                lineIndex++;
                if (lineIndex >= 32) {
                    stop = 1;
                }
                lineWidth = 0;
                charCount = 0;
                endl = TRUE;
                break;
            case MSG_CHAR_READ_STYLE:
                msgStyle = message[i++];
                switch (msgStyle) {
                    case MSG_STYLE_CHOICE:
                        i += 4;
                        break;
                    case MSG_STYLE_POSTCARD:
                        i++;
                        break;
                    case MSG_STYLE_RIGHT:
                    case MSG_STYLE_LEFT:
                    case MSG_STYLE_CENTER:
                    case MSG_STYLE_TATTLE:
                    case MSG_STYLE_INSPECT:
                    case MSG_STYLE_SIGN:
                    case MSG_STYLE_LAMPPOST:
                    case MSG_STYLE_POPUP:
                    case MSG_STYLE_B:
                        break;
                }
                break;
            case MSG_CHAR_READ_END:
                lineWidths[lineIndex] = lineWidth;
                lineCharNumbers[lineIndex] = charCount;
                lineIndex++;
                stop = TRUE;
                break;
            case MSG_CHAR_READ_FUNCTION:
                functionCode = message[i++];
                switch (functionCode) {
                    case MSG_READ_FUNC_FONT:
                        font = message[i++];
                        break;
                    case MSG_READ_FUNC_RESET_GFX:
                    case MSG_READ_FUNC_NO_SKIP:
                    case MSG_READ_FUNC_INPUT_OFF:
                    case MSG_READ_FUNC_INPUT_ON:
                    case MSG_READ_FUNC_DELAY_OFF:
                    case MSG_READ_FUNC_DELAY_ON:
                    case MSG_READ_FUNC_SAVE_POS:
                    case MSG_READ_FUNC_RESTORE_POS:
                    case MSG_READ_FUNC_SAVE_COLOR:
                    case MSG_READ_FUNC_RESTORE_COLOR:
                    case MSG_READ_FUNC_ENABLE_CDOWN_NEXT:
                        break;
                    default:
                        stop = TRUE;
                        break;
                    case MSG_READ_FUNC_CUSTOM_VOICE:
                        i++;
                        // fallthrough
                    temp = 4;
                    case MSG_READ_FUNC_IMAGE:
                        i += temp;
                        // fallthrough
                    case MSG_READ_FUNC_ANIM_SPRITE:
                    case MSG_READ_FUNC_ANIM_DELAY:
                        i++;
                        // fallthrough
                    case MSG_READ_FUNC_SPEED:
                    case MSG_READ_FUNC_SET_X:
                    case MSG_READ_FUNC_ANIM_LOOP:
                        i++;
                        // fallthrough
                    case MSG_READ_FUNC_COLOR:
                    case MSG_READ_FUNC_SPACING:
                    case MSG_READ_FUNC_SCROLL:
                    case MSG_READ_FUNC_SET_Y:
                    case MSG_READ_FUNC_RIGHT:
                    case MSG_READ_FUNC_DOWN:
                    case MSG_READ_FUNC_UP:
                    case MSG_READ_FUNC_INLINE_IMAGE:
                    case MSG_READ_FUNC_ITEM_ICON:
                    case MSG_READ_FUNC_HIDE_IMAGE:
                    case MSG_READ_FUNC_ANIM_DONE:
                    case MSG_READ_FUNC_CURSOR:
                    case MSG_READ_FUNC_END_CHOICE:
                    case MSG_READ_FUNC_SET_CANCEL:
                    case MSG_READ_FUNC_OPTION:
                    case MSG_READ_FUNC_END_FX:
                    case MSG_READ_FUNC_SET_REWIND:
                    case MSG_READ_FUNC_VOICE:
                        i++;
                        break;
                    case MSG_READ_FUNC_CENTER_X:
                        if (message[i] == 0) {
                            stop = TRUE;
                        }
                        i++;
                        break;
                    case MSG_READ_FUNC_YIELD:
                        if (message[i] == MSG_CHAR_READ_END) {
                            stop = TRUE;
                        }
                        break;
                    case MSG_READ_FUNC_SIZE:
                        packedScaleY = message[i + 1];
                        i += 2;
                        scale = (f32)(packedScaleY >> 4) + ((packedScaleY & 0xF) * 0.0625f);
                        break;
                    case MSG_READ_FUNC_SIZE_RESET:
                        scale = 1.0f;
                        break;
                    case MSG_READ_FUNC_START_FX:
                        switch (message[i++]) {
                            case MSG_FX_STATIC:
                            case MSG_FX_BLUR:
                            case MSG_FX_DITHER_FADE:
                                i++;
                                break;
                            case MSG_FX_SHAKE:
                            case MSG_FX_WAVE:
                            case MSG_FX_NOISE_OUTLINE:
                            case MSG_FX_RAINBOW:
                            case MSG_FX_GLOBAL_WAVE:
                            case MSG_FX_GLOBAL_RAINBOW:
                            case MSG_FX_RISE_PRINT:
                            case MSG_FX_GROW_PRINT:
                            case MSG_FX_SIZE_JITTER:
                            case MSG_FX_SIZE_WAVE:
                            case MSG_FX_DROP_SHADOW:
                                break;
                        }
                        break;
                    case MSG_READ_FUNC_VAR:
                        lineWidth += get_msg_width((s32)gMessageMsgVars[message[i++]], 0);
                        break;
                }
                break;
            case MSG_CHAR_READ_UNK_CHAR_FA:
                break;
            case MSG_CHAR_READ_SPACE:
            case MSG_CHAR_READ_FULL_SPACE:
            case MSG_CHAR_READ_HALF_SPACE:
                spaceCount++;
                // fallthrough
            default:
                if (endl) {
                    lineCount++;
                    linesOnPage++;
                    endl = FALSE;
                }
 
#if VERSION_IQUE
                if (prevChar >= MSG_CHAR_MULTIBYTE_FIRST && prevChar <= MSG_CHAR_MULTIBYTE_LAST) {
                    break;
                }
#endif
 
                lineWidth += msg_get_print_char_width(c, font, varIndex, scale, 0, 1);
                charCount++;
                break;
        }
    } while (!stop);
 
    if (buffer != NULL) {
        general_heap_free(buffer);
    }
 
    for (i = 0; i < lineIndex; i++) {
        if (maxLineWidth < lineWidths[i]) {
            maxLineWidth = lineWidths[i];
        }
        if (maxCharsPerLine < lineCharNumbers[i]) {
            maxCharsPerLine = lineCharNumbers[i];
        }
    }
 
    if (pageCount == 0) {
        maxLinesOnPage = linesOnPage;
    } else {
        for (i = 0; i < pageCount; i++) {
            if (maxLinesOnPage < linesPerPage[i]) {
                maxLinesOnPage = linesPerPage[i];
            }
        }
    }
 
    if (width != NULL) {
        *width = maxLineWidth;
    }
    if (height != NULL) {
        *height = lineCount * MsgCharsets[font]->newLineY;
    }
    if (maxLineChars != NULL) {
        *maxLineChars = maxCharsPerLine;
    }
    if (numLines != NULL) {
        *numLines = lineCount;
    }
    if (maxLinesPerPage != NULL) {
        *maxLinesPerPage = maxLinesOnPage;
    }
    if (numSpaces != NULL) {
        *numSpaces = spaceCount;
    }
}

Referenced by _msg_get_printer_for_msg(), draw_msg(), get_msg_lines(), get_msg_width(), pause_handle_input(), and pause_tutorial_draw_contents().

◆ replace_window_update()

void replace_window_update	(	s32	idx,
		s8	arg1,
		WindowUpdateFunc	pendingFunc )

Definition at line 426 of file windows.c.

                                                                                    {
    if (gWindows[windowID].flags & WINDOW_FLAG_INITIALIZED) {
        gWindows[windowID].flags |= WINDOW_FLAG_FPUPDATE_CHANGED | WINDOW_FLAG_INITIAL_ANIMATION;
        gWindows[windowID].fpPending = pendingFunc;
        gWindows[windowID].originalPriority = priority;
    }
}

Referenced by pause_tabs_handle_input().

◆ decode_yay0()

void decode_yay0	(	void *	src,
		void *	dst )

Referenced by btl_state_update_normal_start(), load_battle_hit_asset(), load_map_bg(), load_map_by_IDs(), load_map_hit_asset(), pause_partners_load_portrait(), spr_load_sprite(), state_init_title_screen(), state_step_end_battle(), and state_step_unpause().

◆ ai_check_player_dist()

s32 ai_check_player_dist	(	Enemy *	enemy,
		s32	arg1,
		f32	arg2,
		f32	arg3 )

Definition at line 515 of file 23680.c.

                                                                              {
    PlayerStatus* playerStatus = &gPlayerStatus;
    Npc* npc = get_npc_unsafe(enemy->npcID);
    f32 posX, posZ;
 
    if (chance >= 0) {
        s32 skipCheckForPlayer;
 
        if (chance != 0) {
            skipCheckForPlayer = rand_int(chance + 1);
        } else {
            skipCheckForPlayer = 0;
        }
 
        if (skipCheckForPlayer == 0) {
            posX = npc->pos.x;
            posZ = npc->pos.z;
            add_vec2D_polar(&posX, &posZ, moveSpeed, 270.0f - npc->renderYaw);
 
            if (dist2D(posX, posZ, playerStatus->pos.x, playerStatus->pos.z) <= radius) {
                return TRUE;
            }
        }
    }
 
    return FALSE;
}

Referenced by CleftAI_CanSeePlayer(), and ProjectileHitbox_GetUsableProjectileID().

◆ pause_init()

void pause_init ( void )

Definition at line 605 of file pause_main.c.

                      {
    s32 posX;
    s32 x;
    Window* pauseWindows;
    MenuPanel** menuPanels;
    s32 i;
 
    DMA_COPY_SEGMENT(ui_images_filemenu_pause);
 
    for (i = 0; i < ARRAY_COUNT(gPauseHudScripts); i++) {
        gPauseCommonHIDs[i] = hud_element_create(gPauseHudScripts[i]);
        if (gPauseHudScripts[i] == &HES_AnimatedCursorHand) {
            hud_element_set_flags(gPauseCommonHIDs[i], HUD_ELEMENT_FLAG_DROP_SHADOW | HUD_ELEMENT_FLAG_80);
        } else {
            hud_element_set_flags(gPauseCommonHIDs[i], HUD_ELEMENT_FLAG_80);
        }
    }
 
    gPauseCursorHID = gPauseCommonHIDs[0];
    setup_pause_menu_tab(gPauseCommonWindowsBPs, ARRAY_COUNT(gPauseCommonWindowsBPs));
    gPauseShownDescMsg = 0;
    gPauseDescTextPos = 0;
    gPauseDescTextOffset = 0;
    gPauseDescTextMaxPos = 0;
    gPauseShownDescIconScript = 0;
    gPauseCurrentDescMsg = MSG_NONE;
    gPauseCurrentDescIconScript = 0;
    gPauseMenuCurrentTab = 0;
 
    menuPanels = gPausePanels;
    for (i = 0; i < ARRAY_COUNT(gPausePanels); menuPanels++, i++) {
        if ((*menuPanels)->fpInit) {
            (*menuPanels)->fpInit(*menuPanels);
        }
    }
 
    posX = 225;
    for (i = 6; i > 0; i--) {
        if (!gPausePanels[i]->initialized) {
            set_window_update(WIN_PAUSE_TUTORIAL + i, WINDOW_UPDATE_HIDE);
        } else {
            gWindows[WIN_PAUSE_TUTORIAL + i].pos.x = posX + 14;
            posX -= 45;
        }
    }
    pauseWindows = &gWindows[WIN_PAUSE_TAB_STATS];
    x = pauseWindows[gPausePanels[0]->col].pos.x;
    gWindows[WIN_PAUSE_TAB_INVIS].pos.x = x + 6;
 
    if (evt_get_variable(NULL, GF_Tutorial_Badges)) {
        for (i = 0; i < ARRAY_COUNT(gPauseTutorialSpriteAnims); i++) {
            gPauseTutorialSprites[i] = spr_load_npc_sprite(gPauseTutorialSpriteAnims[i][0], gPauseTutorialSpriteAnims[i]);
        }
 
        set_window_update(WIN_PAUSE_TUTORIAL, WINDOW_UPDATE_SHOW);
        sfx_play_sound(SOUND_MENU_SHOW_CHOICE);
    }
 
    update_window_hierarchy(WIN_PAUSE_CURSOR, 64);
}

Referenced by state_step_pause().

◆ pause_handle_input()

void pause_handle_input	(	s32	buttonsPressed,
		s32	buttonsHeld )

Definition at line 718 of file pause_main.c.

                                               {
    s32 height;
    s32 width;
    s32 maxLineChars;
    s32 numLines;
    s32 i,j;
    MenuPanel** menuPanels;
    s32 currentDescMsg = gPauseCurrentDescMsg;
    MenuPanel* currentPanel = gPausePanels[gPauseMenuCurrentTab];
 
    if (evt_get_variable(NULL, GF_Tutorial_Badges)) {
        for (i = 0; i < ARRAY_COUNT(gPauseTutorialSprites); i++) {
            spr_update_sprite(gPauseTutorialSprites[i], gPauseTutorialSpriteAnims[i][1], 1.0f);
        }
    }
 
    gPausePressedButtons = pressed;
    gPauseHeldButtons = held;
    if (evt_get_variable(NULL, GF_Tutorial_Badges)) {
        pause_tutorial_input(&gPausePressedButtons, &gPauseHeldButtons);
    }
 
    if ((gPausePressedButtons & BUTTON_START) || (gPauseMenuCurrentTab == 0) && (gPausePressedButtons & BUTTON_B)) {
        enforce_hpfp_limits();
        sfx_play_sound(SOUND_MENU_CLOSE);
        set_game_mode(GAME_MODE_UNPAUSE);
        return;
    }
 
    if (gPauseCurrentDescIconScript != gPauseShownDescIconScript) {
        gPauseShownDescIconScript = gPauseCurrentDescIconScript;
    }
 
    if (currentDescMsg != gPauseShownDescMsg) {
        gPauseShownDescMsg = currentDescMsg;
        gPauseDescTextPos = 0;
        gPauseDescTextOffset = 0;
        if (currentDescMsg != 0) {
            get_msg_properties(currentDescMsg, &height, &width, &maxLineChars, &numLines, NULL, NULL, 0);
            if (numLines % 2) {
                numLines++;
            }
            gPauseDescTextMaxPos = numLines - 2;
            if (gPauseDescTextMaxPos < 0) {
                gPauseDescTextMaxPos = 0;
            }
        } else {
            gPauseDescTextMaxPos = 0;
        }
    }
    if (gPauseHeldButtons & BUTTON_C_UP) {
        gPauseDescTextPos -= 2;
        if (gPauseDescTextPos < 0) {
            gPauseDescTextPos = 0;
        }
    }
    if (gPauseHeldButtons & BUTTON_C_DOWN) {
        gPauseDescTextPos += 2;
        if (gPauseDescTextPos > gPauseDescTextMaxPos) {
            gPauseDescTextPos = gPauseDescTextMaxPos;
        }
    }
    gPauseDescTextOffset += pause_interp_text_scroll(gPauseDescTextPos * 16 - gPauseDescTextOffset);
    if (currentPanel->initialized) {
        if (currentPanel->fpHandleInput) {
            currentPanel->fpHandleInput(currentPanel);
        }
    }
    menuPanels = gPausePanels;
    for (i = 0; i < ARRAY_COUNT(gPausePanels); menuPanels++, i++) {
        if ((*menuPanels)->initialized) {
            if ((*menuPanels)->fpUpdate) {
                (*menuPanels)->fpUpdate(*menuPanels);
            }
        }
    }
}

Referenced by state_step_pause().

◆ pause_cleanup()

void pause_cleanup ( void )

Definition at line 796 of file pause_main.c.

                         {
    s32 i;
    MenuPanel** menuPanels;
 
    for (i = 0; i < ARRAY_COUNT(gPauseCommonHIDs); i++) {
        hud_element_free(gPauseCommonHIDs[i]);
    }
 
    if (evt_get_variable(NULL, GF_Tutorial_Badges)) {
        for (i = 0; i < ARRAY_COUNT(gPauseTutorialSprites); i++) {
            spr_free_sprite(gPauseTutorialSprites[i]);
        }
    }
 
    menuPanels = gPausePanels;
    for (i = 0; i < ARRAY_COUNT(gPausePanels); menuPanels++, i++) {
        if ((*menuPanels)->initialized) {
            if ((*menuPanels)->fpCleanup) {
                (*menuPanels)->fpCleanup(*menuPanels);
            }
        }
    }
 
    for (i = WIN_PAUSE_MAIN; i < WIN_PAUSE_CURSOR; i++)
        set_window_update(i, WINDOW_UPDATE_HIDE);
 
    set_window_update(WIN_PAUSE_CURSOR, WINDOW_UPDATE_HIDE);
}

Referenced by state_step_unpause().

◆ filemenu_init()

void filemenu_init ( s32 mode )

Definition at line 880 of file filemenu_common.c.

                             {
    MenuPanel* menu;
    s32 i;
 
    DMA_COPY_SEGMENT(ui_images_filemenu_pause);
 
    for (i = 0; i < ARRAY_COUNT(filemenu_cursorHIDs); i++) {
        filemenu_cursorHIDs[i] = hud_element_create(filemenu_cursor_hudElemScripts[i]);
        hud_element_set_flags(filemenu_cursorHIDs[i], HUD_ELEMENT_FLAG_DROP_SHADOW | HUD_ELEMENT_FLAG_80);
    }
 
    filemenu_cursorHID = filemenu_cursorHIDs[0];
    if (mode == 0) {
        filemenu_common_windowBPs[0].style.customStyle->background.imgData = NULL; // ???
    }
    setup_pause_menu_tab(filemenu_common_windowBPs, ARRAY_COUNT(filemenu_common_windowBPs));
 
    filemenu_currentMenu = FILE_MENU_MAIN;
    menu = filemenu_menus[FILE_MENU_MAIN];
 
    menu->state = FM_MAIN_SELECT_FILE;
 
    if (menu->state == FM_MAIN_SELECT_FILE) {
        for (i = 0; i < ARRAY_COUNT(filemenu_menus); i++) {
            if (fio_load_game(i)) {
                gSaveSlotSummary[i] = gCurrentSaveFile.summary;
                gSaveSlotMetadata[i].hasData = TRUE;
                gSaveSlotMetadata[i].validData = strcmp(gCurrentSaveFile.modName, DX_MOD_NAME) == 0;
                memcpy(gSaveSlotMetadata[i].modName, gCurrentSaveFile.modName, ARRAY_COUNT(gSaveSlotMetadata[i].modName));
            } else {
                gSaveSlotMetadata[i].hasData = FALSE;
                gSaveSlotMetadata[i].validData = FALSE;
                memset(gSaveSlotMetadata[i].modName, ARRAY_COUNT(gSaveSlotMetadata[i].modName), 0);
            }
        }
 
        fio_load_globals();
        if (gSaveGlobals.lastFileSelected >= 4) {
            gSaveGlobals.lastFileSelected = 0;
        }
        gGameStatusPtr->saveSlot = gSaveGlobals.lastFileSelected;
    }
 
    filemenu_set_selected(menu, (gGameStatusPtr->saveSlot & 1) * 2, gGameStatusPtr->saveSlot >> 1);
 
    for (i = 0; i < ARRAY_COUNT(filemenu_menus); i++) {
        menu = filemenu_menus[i];
        if (menu->fpInit != NULL) {
            menu->fpInit(menu);
        }
    }
    update_window_hierarchy(WIN_PAUSE_DECRIPTION, 64);
}

Referenced by state_step_file_select().

◆ filemenu_cleanup()

void filemenu_cleanup ( void )

Definition at line 934 of file filemenu_common.c.

                            {
    MenuPanel* menu;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(filemenu_cursorHIDs); i++) {
        hud_element_free(filemenu_cursorHIDs[i]);
    }
 
    for (i = 0; i < ARRAY_COUNT(filemenu_menus); i++) {
        menu = filemenu_menus[i];
        if (menu->initialized) {
            if (menu->fpCleanup != NULL) {
                menu->fpCleanup(menu);
            }
        }
    }
 
    for (i = WIN_FILES_MAIN; i < ARRAY_COUNT(gWindows); i++) {
        set_window_update(i, WINDOW_UPDATE_HIDE);
    }
 
    set_window_update(WIN_PAUSE_TUTORIAL, WINDOW_UPDATE_HIDE);
    set_window_update(WIN_PAUSE_DECRIPTION, WINDOW_UPDATE_HIDE);
    filemenu_get_exit_mode(); // part of a conditional that optimized out?
}

Referenced by state_step_exit_file_select().

◆ filemenu_update()

void filemenu_update ( void )

Definition at line 260 of file filemenu_common.c.

                           {
    MenuPanel* menu;
    s32 i;
 
    for (i = WIN_FILES_MAIN; i < ARRAY_COUNT(gWindows); i++) {
        if ((gWindows[i].parent == WIN_NONE || gWindows[i].parent == WIN_FILES_MAIN) &&
            (gWindows[i].flags & WINDOW_FLAG_INITIAL_ANIMATION))
        {
            break;
        }
    }
 
    if (i >= ARRAY_COUNT(gWindows)) {
        filemenu_heldButtons = gGameStatusPtr->heldButtons[0];
        filemenu_pressedButtons = gGameStatusPtr->pressedButtons[0];
    } else {
        filemenu_heldButtons = 0;
        filemenu_pressedButtons = 0;
    }
 
    // B overrides A
    if (filemenu_pressedButtons & BUTTON_B) {
        filemenu_pressedButtons &= ~BUTTON_A;
    }
    if (filemenu_heldButtons & BUTTON_B) {
        filemenu_heldButtons &= ~BUTTON_A;
    }
 
    // only process inputs for the current menu
    menu = filemenu_menus[filemenu_currentMenu];
    if (menu->initialized) {
        if (menu->fpHandleInput != NULL) {
            menu->fpHandleInput(menu);
        }
    }
 
    // update all menus
    for (i = 0; i < ARRAY_COUNT(filemenu_menus); i++) {
        menu = filemenu_menus[i];
        if (menu->initialized && menu->fpUpdate != NULL) {
            menu->fpUpdate(menu);
        }
    }
}

Referenced by state_step_file_select().

◆ filemenu_get_exit_mode()

s32 filemenu_get_exit_mode ( void )

Definition at line 960 of file filemenu_common.c.

                             {
    if (filemenu_menus[FILE_MENU_MAIN]->state == FM_MAIN_SELECT_FILE
        && filemenu_currentMenu == FILE_MENU_CONFIRM
        && filemenu_menus[FILE_MENU_CONFIRM]->selected == 0
    ) {
        return 2;
    }
 
    if (filemenu_menus[FILE_MENU_MAIN]->state == FM_MAIN_SELECT_FILE
        && filemenu_menus[FILE_MENU_MAIN]->selected <= FM_MAIN_OPT_FILE_4
    ) {
        return 1;
    }
 
    return 0;
}

Referenced by filemenu_cleanup(), state_init_exit_file_select(), and state_step_exit_file_select().

◆ filemenu_set_selected()

void filemenu_set_selected	(	MenuPanel *	menu,
		s32	col,
		s32	row )

Definition at line 151 of file filemenu_common.c.

                                                              {
    menu->col = col;
    menu->row = row;
    menu->selected = menu->gridData[(menu->state * menu->numCols * menu->numRows) +
                                    (menu->numCols * menu->row) + menu->col];
}

Referenced by filemenu_choose_name_handle_input(), filemenu_info_handle_input(), filemenu_init(), filemenu_main_handle_input(), and filemenu_yesno_handle_input().

◆ filemenu_set_cursor_alpha()

void filemenu_set_cursor_alpha ( s32 arg0 )

Definition at line 158 of file filemenu_common.c.

                                          {
    filemenu_cursorGoalAlpha = alpha;
    filemenu_cursorGoalAlpha2 = alpha;
}

Referenced by filemenu_info_draw_message_contents().

◆ filemenu_set_cursor_goal_pos()

void filemenu_set_cursor_goal_pos	(	s32	windowIndex,
		s32	posX,
		s32	posY )

Definition at line 163 of file filemenu_common.c.

                                                                    {
    Window* window = &gWindows[windowID];
 
    if (D_80249BB0 || get_game_mode() == GAME_MODE_END_FILE_SELECT) {
        if (D_80249BB0) {
            s32 i;
 
            for (i = WIN_FILES_MAIN; i < ARRAY_COUNT(gWindows); i++) {
                Window* window = &gWindows[i];
                s8 parent = window->parent;
 
                if ((parent == WIN_NONE || parent == WIN_FILES_MAIN) && (window->flags & WINDOW_FLAG_INITIAL_ANIMATION)) {
                    break;
                }
            }
            if (i >= ARRAY_COUNT(gWindows)) {
                D_80249BB0 = FALSE;
            }
        }
        filemenu_cursor_targetX = posX;
        filemenu_cursor_posX = posX;
        filemenu_cursor_targetY = posY;
        filemenu_cursor_posY = posY;
    } else if (!(window->flags & WINDOW_FLAG_INITIAL_ANIMATION) &&
                (window->parent == WIN_NONE || !(gWindows[window->parent].flags & WINDOW_FLAG_INITIAL_ANIMATION))) {
        filemenu_cursor_targetX = posX;
        filemenu_cursor_targetY = posY;
    }
}

Referenced by filemenu_draw_contents_choose_name(), filemenu_draw_contents_file_title(), filemenu_draw_contents_option_center(), filemenu_draw_contents_option_left(), filemenu_draw_contents_option_right(), and filemenu_yesno_draw_options_contents().

◆ filemenu_get_menu_message()

u8 * filemenu_get_menu_message ( s32 idx )

Definition at line 660 of file filemenu_msg.c.

                                       {
#if VERSION_PAL
    return gFileMenuMessages_intl[gCurrentLanguage][idx];
#else
    return (u8*)gFileMenuMessages[idx];
#endif
}

Referenced by filemenu_draw_contents_file_create_header(), filemenu_draw_contents_file_info(), filemenu_draw_contents_file_title(), filemenu_draw_contents_option_center(), filemenu_draw_contents_option_left(), filemenu_draw_contents_option_right(), filemenu_draw_contents_title(), filemenu_info_draw_message_contents(), filemenu_yesno_draw_options_contents(), and filemenu_yesno_draw_prompt_contents().

◆ gfx_task_background()

void gfx_task_background ( void )

Definition at line 169 of file main_loop.c.

                               {
    gDisplayContext = &DisplayContexts[gCurrentDisplayContextIndex];
    gMainGfxPos = &gDisplayContext->backgroundGfx[0];
 
    gfx_init_state();
    gfx_draw_background();
 
    gDPFullSync(gMainGfxPos++);
    gSPEndDisplayList(gMainGfxPos++);
 
    // TODO these << 3 >> 3 shouldn't be necessary. There's almost definitely something we're missing here...
    ASSERT((s32)((u32)((gMainGfxPos - gDisplayContext->backgroundGfx) << 3) >> 3) < ARRAY_COUNT(
               gDisplayContext->backgroundGfx))
 
    nuGfxTaskStart(&gDisplayContext->backgroundGfx[0], (u32)(gMainGfxPos - gDisplayContext->backgroundGfx) * 8,
                   NU_GFX_UCODE_F3DEX2, NU_SC_NOSWAPBUFFER);
}

Referenced by gfxRetrace_Callback().

◆ update_enemy_shadows()

void update_enemy_shadows ( void )

Definition at line 815 of file actor_rendering.c.

                                {
    BattleStatus* battleStatus = &gBattleStatus;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
        update_nonplayer_actor_shadow(FALSE, battleStatus->enemyActors[i]);
    }
}

Referenced by update_nonplayer_actor_shadows().

◆ update_hero_shadows()

void update_hero_shadows ( void )

Definition at line 824 of file actor_rendering.c.

                               {
    update_nonplayer_actor_shadow(TRUE, gBattleStatus.partnerActor);
    update_player_actor_shadow();
}

Referenced by update_nonplayer_actor_shadows().

◆ appendGfx_background_texture()

void appendGfx_background_texture ( void )

Bug: xh = 2 * bgXOffset + (bgMinX - 1) * 4

Bug: xh = 2 * bgXOffset + (bgMinX - 1) * 4

Definition at line 62 of file background.c.

                                        {
    Camera* cam = &gCameras[gCurrentCameraID];
    u16 flags = 0;
    s32 fogR, fogG, fogB, fogA;
    u8 r1, g1, b1, a1;
    u8 r2, g2, b2;
    u16 blendedR, blendedG, blendedB;
    s32 i;
 
    f32 theta, sinTheta, cosTheta, scrollValue, f5, waveOffset;
 
    s32 bgMinX;
    s32 bgMinY;
    s32 bgMaxX;
    s32 bgMaxY;
    s32 lineHeight;
    s32 numLines;
    s32 extraHeight;
 
    s32 bgXOffset;
    s16 texOffsetY;
 
    u8* newvar;
 
    enum {
        BG_BLEND_NONE           = 0,
        BG_BLEND_HAS_FOG        = 1,
        BG_BLEND_SHOULD_LERP    = 2,
        BG_BLEND_SHOULD_BLEND   = 4,
    };
 
    if (is_world_fog_enabled()) {
        get_world_fog_color(&fogR, &fogG, &fogB, &fogA);
        flags = BG_BLEND_HAS_FOG;
        fogA = gGameStatusPtr->backgroundDarkness;
    }
 
    switch (*gBackgroundTintModePtr) {
        case ENV_TINT_NONE:
        case ENV_TINT_SHROUD:
            mdl_get_shroud_tint_params(&r1, &g1, &b1, &a1);
            if (a1 != 0) {
                flags |= BG_BLEND_SHOULD_LERP;
            }
            break;
        case ENV_TINT_DEPTH:
        case ENV_TINT_REMAP:
        default:
            mdl_get_remap_tint_params(&r1, &g1, &b1, &r2, &g2, &b2);
            if (!(r1 == 255 && g1 == 255 && b1 == 255 && r2 == 0 && g2 == 0 && b2 == 0)) {
                flags |= BG_BLEND_SHOULD_BLEND;
            }
            break;
    }
 
    switch (flags) {
        case BG_BLEND_NONE:
            gGameStatusPtr->backgroundFlags &= ~BACKGROUND_FLAG_FOG;
            break;
        case BG_BLEND_HAS_FOG:
            gGameStatusPtr->backgroundFlags |= BACKGROUND_FLAG_FOG;
            break;
        case BG_BLEND_SHOULD_LERP:
            gGameStatusPtr->backgroundFlags |= BACKGROUND_FLAG_FOG;
            fogR = r1;
            fogG = g1;
            fogB = b1;
            fogA = a1;
            break;
        case BG_BLEND_HAS_FOG | BG_BLEND_SHOULD_LERP:
            gGameStatusPtr->backgroundFlags |= BACKGROUND_FLAG_FOG;
            fogR = (fogR * (255 - a1) + r1 * a1) / 255;
            fogG = (fogG * (255 - a1) + g1 * a1) / 255;
            fogB = (fogB * (255 - a1) + b1 * a1) / 255;
            fogA = (fogA * (255 - a1) + a1 * a1) / 255;
            break;
        case BG_BLEND_SHOULD_BLEND:
            gGameStatusPtr->backgroundFlags |= BACKGROUND_FLAG_FOG;
            break;
    }
 
    if (gGameStatusPtr->backgroundFlags & BACKGROUND_FLAG_FOG) {
        switch (*gBackgroundTintModePtr) {
            case ENV_TINT_NONE:
            case ENV_TINT_SHROUD:
                if (fogA == 255) {
                    for (i = 0; i < ARRAY_COUNT(gBackgroundPalette); i++) {
                        gBackgroundPalette[i] = 1;
                    }
                } else {
                    // lerp from background palette color to fog color based on fog alpha
                    for (i = 0; i < ARRAY_COUNT(gBackgroundPalette); i++) {
                        // NOTE: values after UNPACK range from [0,31], so we need to shift fog color into that range
                        u16 palColor = gGameStatusPtr->backgroundPalette[i];
                        blendedB = blend_background_channel(UNPACK_PAL_B(palColor), fogB >> 3, fogA);
                        blendedG = blend_background_channel(UNPACK_PAL_G(palColor), fogG >> 3, fogA);
                        blendedR = blend_background_channel(UNPACK_PAL_R(palColor), fogR >> 3, fogA);
                        gBackgroundPalette[i] = blendedB << 1 | blendedG << 6 | blendedR << 11 | 1;
                    }
                }
                break;
            case ENV_TINT_DEPTH:
            case ENV_TINT_REMAP:
            default:
                // the background color channels are remapped from [0,255] -> [min,max]
                for (i = 0; i < ARRAY_COUNT(gBackgroundPalette); i++) {
                    // NOTE: values after UNPACK range from [0,31], so we need to shift other colors into that range
                    u16 palColor = gGameStatusPtr->backgroundPalette[i];
                    blendedB = (b2 >> 3) + ((UNPACK_PAL_B(palColor) * b1 >> 3) >> 5);
                    blendedG = (g2 >> 3) + ((UNPACK_PAL_G(palColor) * g1 >> 3) >> 5);
                    blendedR = (r2 >> 3) + ((UNPACK_PAL_R(palColor) * r1 >> 3) >> 5);
 
                    if (blendedB > 0x1F) {
                        blendedB = 0x1F;
                    }
                    if (blendedG > 0x1F) {
                        blendedG = 0x1F;
                    }
                    if (blendedR > 0x1F) {
                        blendedR = 0x1F;
                    }
                    gBackgroundPalette[i] = blendedB << 1 | blendedG << 6 | blendedR << 11 | 1;
                }
                break;
        }
    }
 
    theta = clamp_angle(-cam->curBoomYaw);
    sinTheta = sin_deg(theta);
    cosTheta = cos_deg(theta);
    f5 = cosTheta * cam->lookAt_obj.x - sinTheta * cam->lookAt_obj.z + cam->leadAmount;
    scrollValue = -f5 * 0.25f;
    scrollValue += gGameStatusPtr->backgroundMaxX * theta * (1 / 90.0f);
 
    if (fabsf(scrollValue - gBackroundLastScrollValue) < 0.3f) {
        scrollValue = gBackroundLastScrollValue;
    } else {
        gBackroundLastScrollValue = scrollValue;
    }
 
    while (scrollValue < 0.0f) {
        scrollValue += gGameStatusPtr->backgroundMaxX * 32;
    }
 
    bgXOffset = gGameStatusPtr->backgroundXOffset = ((s32)scrollValue) % gGameStatusPtr->backgroundMaxX;
    bgMaxX = gGameStatusPtr->backgroundMaxX;
    bgMaxY = gGameStatusPtr->backgroundMaxY;
    bgMinX = gGameStatusPtr->backgroundMinX;
    bgMinY = gGameStatusPtr->backgroundMinY;
 
    gDPPipeSync(gMainGfxPos++);
    gDPSetCycleType(gMainGfxPos++, G_CYC_COPY);
    gDPSetTexturePersp(gMainGfxPos++, G_TP_NONE);
    gDPSetTextureLUT(gMainGfxPos++, G_TT_RGBA16);
    gDPSetCombineMode(gMainGfxPos++, G_CC_DECALRGB, G_CC_DECALRGB);
    gDPSetRenderMode(gMainGfxPos++, G_RM_NOOP, G_RM_NOOP2);
    gDPSetTextureFilter(gMainGfxPos++, G_TF_POINT);
    gDPPipeSync(gMainGfxPos++);
 
    if (!(gGameStatusPtr->backgroundFlags & BACKGROUND_FLAG_FOG)) {
        gDPLoadTLUT_pal256(gMainGfxPos++, gGameStatusPtr->backgroundPalette);
    } else {
        gDPLoadTLUT_pal256(gMainGfxPos++, gBackgroundPalette);
    }
 
    if (!gBackroundWaveEnabled) {
        lineHeight = 2048 / gGameStatusPtr->backgroundMaxX;
        numLines = gGameStatusPtr->backgroundMaxY / lineHeight;
        extraHeight = gGameStatusPtr->backgroundMaxY % lineHeight;
        for (i = 0; i < numLines; i++) {
            texOffsetY = gBackroundTextureYOffset + lineHeight * i;
            if (texOffsetY > gGameStatusPtr->backgroundMaxY) {
                texOffsetY -= gGameStatusPtr->backgroundMaxY;
            }
            gDPLoadTextureTile(gMainGfxPos++, gGameStatusPtr->backgroundRaster + bgMaxX * texOffsetY,
                               G_IM_FMT_CI, G_IM_SIZ_8b, bgMaxX, 6,
                               0, 0, 295, 5, 0,
                               G_TX_WRAP, G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
 
            gSPTextureRectangle(gMainGfxPos++, bgMinX * 4, (lineHeight * i + bgMinY) * 4,
                                                 (bgXOffset + bgMinX - 1) * 4, (lineHeight * i + lineHeight - 1 + bgMinY) * 4,
                                                 G_TX_RENDERTILE, (bgMaxX - bgXOffset) * 32, 0, 4096, 1024);
            gSPTextureRectangle(gMainGfxPos++, (bgXOffset + bgMinX) * 4, (lineHeight * i + bgMinY) * 4,
                                                 (bgMaxX + bgMinX - 1) * 4, (lineHeight * i + lineHeight - 1 + bgMinY) * 4,
                                                 G_TX_RENDERTILE, 0, 0, 4096, 1024);
        }
        if (extraHeight != 0) {
            texOffsetY = gBackroundTextureYOffset + lineHeight * i;
            if (texOffsetY > gGameStatusPtr->backgroundMaxY) {
                texOffsetY -= gGameStatusPtr->backgroundMaxY;
            }
            gDPLoadTextureTile(gMainGfxPos++, gGameStatusPtr->backgroundRaster + bgMaxX * texOffsetY,
                               G_IM_FMT_CI, G_IM_SIZ_8b, bgMaxX, extraHeight,
                               0, 0, 295, extraHeight - 1, 0,
                               G_TX_WRAP, G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
            gSPTextureRectangle(gMainGfxPos++, bgMinX * 4, (lineHeight * i + bgMinY) * 4,
                                                 (bgXOffset + bgMinX - 1) * 4, (bgMaxY - 1 + bgMinY) * 4,
                                                 G_TX_RENDERTILE, (bgMaxX - bgXOffset) * 32, 0, 4096, 1024);
            gSPTextureRectangle(gMainGfxPos++, (bgXOffset + bgMinX) * 4, (lineHeight * i + bgMinY) * 4,
                                                 (bgMaxX + bgMinX - 1) * 4, (bgMaxY - 1 + bgMinY) * 4,
                                                 G_TX_RENDERTILE, 0, 0, 4096, 1024);
        }
    } else {
        lineHeight = 6;
        numLines = gGameStatusPtr->backgroundMaxY / lineHeight;
        extraHeight = gGameStatusPtr->backgroundMaxY % lineHeight;
        gBackroundWavePhase += TAU / 60; // 60 frames period
        for (i = 0; i < numLines; i++) {
            waveOffset = sin_rad(gBackroundWavePhase + i * (TAU / 15)) * 3.0f;
            bgXOffset = 2.0f * (gGameStatusPtr->backgroundXOffset + waveOffset);
            texOffsetY = gBackroundTextureYOffset + lineHeight * i;
            if (texOffsetY > gGameStatusPtr->backgroundMaxY) {
                texOffsetY -= gGameStatusPtr->backgroundMaxY;
            }
            gDPLoadTextureTile(gMainGfxPos++, gGameStatusPtr->backgroundRaster + bgMaxX * texOffsetY,
                               G_IM_FMT_CI, G_IM_SIZ_8b, bgMaxX, 6,
                               0, 0, 295, 5, 0,
                               G_TX_WRAP, G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
 
            gSPTextureRectangle(gMainGfxPos++, bgMinX * 4, (lineHeight * i + bgMinY) * 4,
                                                 (2 * bgXOffset + (bgMinX - 1)) * 4, (lineHeight * i + lineHeight - 1 + bgMinY) * 4,
                                                 G_TX_RENDERTILE, bgMaxX * 32 - bgXOffset * 16, 0, 4096, 1024);
            gSPTextureRectangle(gMainGfxPos++, bgXOffset * 2 + bgMinX * 4, (lineHeight * i + bgMinY) * 4,
                                                 (bgMaxX + bgMinX - 1) * 4, (lineHeight * i + lineHeight - 1 + bgMinY) * 4,
                                                 G_TX_RENDERTILE, 0, 0, 4096, 1024);
        }
        if (extraHeight != 0) {
            waveOffset = sin_rad(gBackroundWavePhase + i * (TAU / 15)) * 3.0f;
            bgXOffset = 2.0f * (gGameStatusPtr->backgroundXOffset + waveOffset);
            texOffsetY = gBackroundTextureYOffset + lineHeight * i;
            if (texOffsetY > gGameStatusPtr->backgroundMaxY) {
                texOffsetY -= gGameStatusPtr->backgroundMaxY;
            }
            gDPLoadTextureTile(gMainGfxPos++, gGameStatusPtr->backgroundRaster + bgMaxX * texOffsetY,
                               G_IM_FMT_CI, G_IM_SIZ_8b, bgMaxX, extraHeight,
                               0, 0, 295, extraHeight - 1, 0,
                               G_TX_WRAP, G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
            gSPTextureRectangle(gMainGfxPos++, bgMinX * 4, (lineHeight * i + bgMinY) * 4,
                                                 (2 * bgXOffset + (bgMinX - 1)) * 4, (bgMaxY - 1 + bgMinY) * 4, 
                                                 G_TX_RENDERTILE, bgMaxX * 32 - bgXOffset * 16, 0, 4096, 1024);
            gSPTextureRectangle(gMainGfxPos++, bgXOffset * 2  + bgMinX * 4, (lineHeight * i + bgMinY) * 4,
                                                 (bgMaxX + bgMinX - 1) * 4, (bgMaxY - 1 + bgMinY) * 4, 
                                                 G_TX_RENDERTILE, 0, 0, 4096, 1024);
        }
    }
}

Referenced by gfx_draw_background().

◆ appendGfx_enemy_actor()

void appendGfx_enemy_actor ( void * data )

Definition at line 1375 of file actor_rendering.c.

                                       {
    appendGfx_npc_actor(FALSE, (s32) data);
}

Referenced by btl_render_actors().

◆ appendGfx_enemy_actor_blur()

void appendGfx_enemy_actor_blur ( void * data )

Definition at line 677 of file actor_rendering.c.

                                            {
    Actor* actor = data;
 
    appendGfx_nonplayer_actor_blur(FALSE, actor);
}

Referenced by btl_render_actors().

◆ appendGfx_enemy_actor_reflection()

void appendGfx_enemy_actor_reflection ( void * data )

Definition at line 1383 of file actor_rendering.c.

                                                  {
    Actor* actor = data;
 
    appendGfx_npc_actor_reflection(0, actor);
}

Referenced by btl_render_actors().

◆ appendGfx_partner_actor()

void appendGfx_partner_actor ( void * data )

Definition at line 1379 of file actor_rendering.c.

                                         {
    appendGfx_npc_actor(TRUE, (s32) data);
}

Referenced by btl_render_actors().

◆ appendGfx_partner_actor_blur()

void appendGfx_partner_actor_blur ( void * data )

Definition at line 687 of file actor_rendering.c.

                                              {
    Actor* actor = data;
 
    appendGfx_nonplayer_actor_blur(TRUE, actor);
}

Referenced by btl_render_actors().

◆ appendGfx_partner_actor_reflection()

void appendGfx_partner_actor_reflection ( void * data )

Definition at line 1389 of file actor_rendering.c.

                                                    {
    appendGfx_npc_actor_reflection(1, gBattleStatus.partnerActor);
}

Referenced by btl_render_actors().

◆ appendGfx_player_actor()

void appendGfx_player_actor ( void * arg0 )

Definition at line 1439 of file actor_rendering.c.

                                        {
    BattleStatus* battleStatus = &gBattleStatus;
    PlayerData* playerData = &gPlayerData;
    Matrix4f mtxRotX, mtxRotY, mtxRotZ, mtxRotation;
    Matrix4f mtxScale;
    Matrix4f mtxPivotOn, mtxPivotOff, mtxTranslate;
    Matrix4f mtxTemp, mtxTransform;
 
    Actor* partner;
    Actor* player;
    ActorPart* playerParts;
    EffectInstance* effect;
    f32 playerPosX, playerPosY, playerPosZ, playerYaw;
    s32 animChanged, palChanged, decorChanged, cond4;
    u32 lastAnim;
 
    player = battleStatus->playerActor;
    partner = battleStatus->partnerActor;
    playerParts = player->partsTable;
 
    playerPosX = player->curPos.x + player->headOffset.x;
    playerPosY = player->curPos.y + player->headOffset.y + player->verticalRenderOffset;
    playerPosZ = player->curPos.z + player->headOffset.z;
 
    playerYaw = playerParts->yaw = player->yaw;
 
    player->disableEffect->data.disableX->pos.x = playerPosX +
        (player->actorBlueprint->statusIconOffset.x + player->statusIconOffset.x) * player->scalingFactor;
    player->disableEffect->data.disableX->pos.y = playerPosY +
        (player->actorBlueprint->statusIconOffset.y + player->statusIconOffset.y) * player->scalingFactor;
    player->disableEffect->data.disableX->pos.z = playerPosZ;
 
    if (!(gBattleStatus.flags1 & BS_FLAGS1_TATTLE_OPEN) && (player->flags & ACTOR_FLAG_SHOW_STATUS_ICONS)) {
        if (player->disableDismissTimer != 0) {
            player->disableDismissTimer--;
            player->disableEffect->data.disableX->pos.y = NPC_DISPOSE_POS_Y;
        } else {
            player->disableEffect->data.disableX->scale = player->scalingFactor * 0.75;
        }
    } else {
        player->disableEffect->data.disableX->pos.y = NPC_DISPOSE_POS_Y;
        player->disableDismissTimer = 10;
    }
 
    if (battleStatus->waterBlockTurnsLeft != 0) {
        if ((gBattleStatus.flags1 & BS_FLAGS1_SHOW_PLAYER_DECORATIONS) ||
            (!(gBattleStatus.flags1 & BS_FLAGS1_TATTLE_OPEN) && (player->flags & ACTOR_FLAG_SHOW_STATUS_ICONS)))
        {
            effect = battleStatus->waterBlockEffect;
            effect->data.waterBlock->pos.x = playerPosX;
            effect->data.waterBlock->pos.y = playerPosY;
            effect->data.waterBlock->pos.z = playerPosZ;
        } else {
            effect = battleStatus->waterBlockEffect;
            effect->data.waterBlock->pos.x = playerPosX;
            effect->data.waterBlock->pos.y = NPC_DISPOSE_POS_Y;
            effect->data.waterBlock->pos.z = playerPosZ;
        }
    }
    if (battleStatus->cloudNineTurnsLeft != 0) {
        if ((gBattleStatus.flags1 & BS_FLAGS1_SHOW_PLAYER_DECORATIONS) ||
            (!(gBattleStatus.flags1 & BS_FLAGS1_TATTLE_OPEN) && (player->flags & ACTOR_FLAG_SHOW_STATUS_ICONS)))
        {
            effect = battleStatus->cloudNineEffect;
            effect->data.endingDecals->pos.x = playerPosX;
            effect->data.endingDecals->pos.y = playerPosY;
            effect->data.endingDecals->pos.z = playerPosZ;
            effect->data.endingDecals->scale = player->scalingFactor;
        } else {
            effect = battleStatus->cloudNineEffect;
            effect->data.endingDecals->pos.x = playerPosX;
            effect->data.endingDecals->pos.y = NPC_DISPOSE_POS_Y;
            effect->data.endingDecals->pos.z = playerPosZ;
        }
    }
    if (player->debuff == STATUS_KEY_FROZEN) {
        effect = player->icePillarEffect;
        if (player->icePillarEffect != NULL) {
            if ((gBattleStatus.flags1 & BS_FLAGS1_SHOW_PLAYER_DECORATIONS) ||
                (!(gBattleStatus.flags1 & BS_FLAGS1_TATTLE_OPEN) && (player->flags & ACTOR_FLAG_SHOW_STATUS_ICONS)))
            {
                effect->data.icePillar->pos.x = playerPosX - 8.0f;
                effect->data.icePillar->pos.y = playerPosY;
                effect->data.icePillar->pos.z = playerPosZ;
                effect->data.icePillar->scale = player->size.y / 24.0;
            } else {
                effect->data.icePillar->pos.x = NPC_DISPOSE_POS_X;
                effect->data.icePillar->pos.y = NPC_DISPOSE_POS_Y;
                effect->data.icePillar->pos.z = NPC_DISPOSE_POS_Z;
            }
        } else {
            effect->data.icePillar->pos.x = NPC_DISPOSE_POS_X;
            effect->data.icePillar->pos.y = NPC_DISPOSE_POS_Y;
            effect->data.icePillar->pos.z = NPC_DISPOSE_POS_Z;
        }
    } else {
        effect = player->icePillarEffect;
        if (effect != NULL) {
            effect->flags |= FX_INSTANCE_FLAG_DISMISS;
            player->icePillarEffect = NULL;
        }
    }
 
    if (!(gBattleStatus.flags2 & BS_FLAGS2_HIDE_BUFF_COUNTERS)
        && !(gBattleStatus.flags1 & BS_FLAGS1_TATTLE_OPEN)
        && (player->flags & ACTOR_FLAG_SHOW_STATUS_ICONS)
    ) {
        battleStatus->buffEffect->data.partnerBuff->visible = TRUE;
    } else {
        battleStatus->buffEffect->data.partnerBuff->visible = FALSE;
    }
 
    if (player->debuff == STATUS_KEY_SHRINK) {
        player->scalingFactor += (0.4 - player->scalingFactor) / 6.0;
    } else {
        player->scalingFactor += (1.0 - player->scalingFactor) / 6.0;
    }
 
    if (player->flags & ACTOR_FLAG_SHOW_STATUS_ICONS) {
        if (battleStatus->hammerCharge > 0) {
            create_status_icon_boost_hammer(player->hudElementDataIndex);
            remove_status_icon_boost_jump(player->hudElementDataIndex);
        } else {
            remove_status_icon_boost_hammer(player->hudElementDataIndex);
        }
        if (battleStatus->jumpCharge > 0) {
            create_status_icon_boost_jump(player->hudElementDataIndex);
            remove_status_icon_boost_hammer(player->hudElementDataIndex);
        } else {
            remove_status_icon_boost_jump(player->hudElementDataIndex);
        }
    } else {
        enable_status_icon_boost_jump(player->hudElementDataIndex);
        enable_status_icon_boost_hammer(player->hudElementDataIndex);
    }
 
    if ((player->flags & ACTOR_FLAG_SHOW_STATUS_ICONS) && !(gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE)) {
        if (playerData->curHP <= PERIL_THRESHOLD) {
            create_status_icon_peril(player->hudElementDataIndex);
            remove_status_icon_danger(player->hudElementDataIndex);
        } else if (playerData->curHP <= DANGER_THRESHOLD) {
            remove_status_icon_peril(player->hudElementDataIndex);
            create_status_icon_danger(player->hudElementDataIndex);
        } else {
            remove_status_icon_peril(player->hudElementDataIndex);
            remove_status_icon_danger(player->hudElementDataIndex);
        }
    } else {
        remove_status_icon_peril(player->hudElementDataIndex);
        remove_status_icon_danger(player->hudElementDataIndex);
    }
 
    if (player->transparentStatus == STATUS_KEY_TRANSPARENT) {
        playerParts->flags |= ACTOR_PART_FLAG_TRANSPARENT;
    } else {
        playerParts->flags &= ~ACTOR_PART_FLAG_TRANSPARENT;
    }
 
    animChanged = FALSE;
    palChanged = FALSE;
    decorChanged = FALSE;
    cond4 = FALSE;
    lastAnim = playerParts->curAnimation;
 
    if ((((!(gBattleStatus.flags2 & BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER)
            && (gBattleStatus.flags2 & BS_FLAGS2_PLAYER_TURN_USED))
                && (partner != NULL))
            || (battleStatus->outtaSightActive > 0))
        && !(player->flags & ACTOR_FLAG_NO_INACTIVE_ANIM)
        && !((partner != NULL) && (partner->flags & ACTOR_FLAG_NO_ATTACK))
    ) {
        if (!(gBattleStatus.flags2 & BS_FLAGS2_NO_PLAYER_PAL_ADJUST)) {
            if ((player->debuff != STATUS_KEY_FEAR)
                && (player->debuff != STATUS_KEY_PARALYZE)
                && (player->debuff != STATUS_KEY_FROZEN)
                && (player->debuff != STATUS_KEY_STOP)
            ) {
                if ((player->transparentStatus != STATUS_KEY_TRANSPARENT) &&
                    (player->stoneStatus != STATUS_KEY_STONE) &&
                    ((battleStatus->outtaSightActive > 0) || (gBattleStatus.flags2 & BS_FLAGS2_PLAYER_TURN_USED)))
                {
                    if (is_ability_active(ABILITY_BERSERKER)) {
                        playerParts->curAnimation = get_player_anim_for_status(STATUS_KEY_INACTIVE_BERSERK);
                    } else  if (player->debuff == STATUS_KEY_SLEEP) {
                        playerParts->curAnimation = get_player_anim_for_status(STATUS_KEY_INACTIVE_SLEEP);
                    } else if (player->debuff == STATUS_KEY_DIZZY) {
                        playerParts->curAnimation = get_player_anim_for_status(STATUS_KEY_INACTIVE_DIZZY);
                    } else {
                        playerParts->curAnimation = get_player_anim_for_status(STATUS_KEY_INACTIVE);
                    }
                    spr_update_player_sprite(PLAYER_SPRITE_MAIN, playerParts->curAnimation, playerParts->animationRate);
                    animChanged = TRUE;
                }
            }
 
            if (player->debuff != STATUS_KEY_POISON) {
                set_actor_pal_adjustment(player, ACTOR_PAL_ADJUST_PLAYER_DEBUFF);
            } else {
                set_actor_pal_adjustment(player, ACTOR_PAL_ADJUST_PLAYER_POISON);
            }
            palChanged = TRUE;
 
            set_actor_glow_pal(player, GLOW_PAL_OFF);
            decorChanged = TRUE;
        }
    }
 
    if (player->stoneStatus == STATUS_KEY_STONE) {
        playerParts->curAnimation = get_player_anim_for_status(STATUS_KEY_STONE);
        spr_update_player_sprite(PLAYER_SPRITE_MAIN, playerParts->curAnimation, playerParts->animationRate);
        animChanged = TRUE;
 
        if (!palChanged) {
            set_actor_pal_adjustment(player, ACTOR_PAL_ADJUST_NONE);
        }
        set_actor_glow_pal(player, GLOW_PAL_OFF);
        palChanged = TRUE;
        enable_status_debuff(player->hudElementDataIndex);
        decorChanged = TRUE;
        enable_status_static(player->hudElementDataIndex);
        cond4 = TRUE;
 
        enable_status_transparent(player->hudElementDataIndex);
        enable_status_chill_out(player->hudElementDataIndex);
    }
 
    if ((player->flags & ACTOR_FLAG_USING_IDLE_ANIM) && !animChanged) {
        s32 temp = playerParts->curAnimation;
        if (temp == get_player_anim_for_status(STATUS_KEY_STONE)) {
            playerParts->curAnimation = get_player_anim_for_status(STATUS_KEY_NORMAL);
        }
    }
 
    if (is_ability_active(ABILITY_BERSERKER)) {
        if (!palChanged) {
            set_actor_pal_adjustment(player, ACTOR_PAL_ADJUST_BERSERK);
        }
        palChanged = TRUE;
    }
    if (player->debuff == STATUS_KEY_POISON) {
        if (!palChanged) {
            set_actor_pal_adjustment(player, ACTOR_PAL_ADJUST_POISON);
        }
        palChanged = TRUE;
    }
    if (player->debuff == STATUS_KEY_PARALYZE) {
        if (!palChanged) {
            set_actor_pal_adjustment(player, ACTOR_PAL_ADJUST_PARALYZE);
        }
        palChanged = TRUE;
    }
    if (player->staticStatus == STATUS_KEY_STATIC) {
        if (!palChanged) {
            set_actor_pal_adjustment(player, ACTOR_PAL_ADJUST_STATIC);
        }
        palChanged = TRUE;
    }
    if (battleStatus->turboChargeTurnsLeft != 0) {
        if (!decorChanged) {
            set_actor_glow_pal(player, GLOW_PAL_ON);
        }
        decorChanged = TRUE;
    }
    if (is_ability_active(ABILITY_ZAP_TAP)) {
        if (!palChanged) {
            set_actor_pal_adjustment(player, ACTOR_PAL_ADJUST_STATIC);
        }
        palChanged = TRUE;
    }
    if (!palChanged) {
        set_actor_pal_adjustment(player, ACTOR_PAL_ADJUST_NONE);
    }
    if (!decorChanged) {
        set_actor_glow_pal(player, GLOW_PAL_OFF);
    }
    if (player->flags & ACTOR_FLAG_USING_IDLE_ANIM) {
        if (battleStatus->hustleTurns != 0) {
            playerParts->curAnimation = get_player_anim_for_status(STATUS_KEY_HUSTLE);
            animChanged = TRUE;
        } else if (!animChanged) {
            s32 temp = get_player_anim_for_status(STATUS_KEY_NORMAL);
            if (temp == get_player_anim_for_status(STATUS_KEY_HUSTLE)) {
                playerParts->curAnimation = get_player_anim_for_status(STATUS_KEY_NORMAL);
            }
        }
 
        if (player->debuff == STATUS_KEY_FROZEN) {
            if (!animChanged) {
                playerParts->curAnimation = get_player_anim_for_status(STATUS_KEY_FROZEN);
                animChanged = TRUE;
            }
        } else if (player->debuff != STATUS_KEY_SHRINK) {
            if (player->debuff == STATUS_KEY_POISON) {
                if (!animChanged) {
                    playerParts->curAnimation = get_player_anim_for_status(STATUS_KEY_POISON);
                    animChanged = TRUE;
                }
            } else if (player->debuff == STATUS_KEY_DIZZY) {
                if (!animChanged) {
                    playerParts->curAnimation = get_player_anim_for_status(STATUS_KEY_DIZZY);
                    animChanged = TRUE;
                }
            } else if (player->debuff == STATUS_KEY_SLEEP) {
                if (!animChanged) {
                    playerParts->curAnimation = get_player_anim_for_status(STATUS_KEY_SLEEP);
                    animChanged = TRUE;
                }
            } else if (player->debuff == STATUS_KEY_PARALYZE) {
                if (!animChanged) {
                    playerParts->curAnimation = get_player_anim_for_status(STATUS_KEY_PARALYZE);
                    animChanged = TRUE;
                }
                } else {
                if (player_team_is_ability_active(player, ABILITY_BERSERKER)) {
                    if (!animChanged) {
                        playerParts->curAnimation = get_player_anim_for_status(STATUS_KEY_BERSERK);
                        animChanged = TRUE;
                    }
                }
            }
        }
        if (is_ability_active(ABILITY_ZAP_TAP)) {
            if (!animChanged) {
                playerParts->curAnimation = get_player_anim_for_status(STATUS_KEY_STATIC);
                animChanged = TRUE;
            }
            player->staticStatus = STATUS_KEY_STATIC;
            player->staticDuration = 127;
        } else if ((player->staticStatus == STATUS_KEY_STATIC) && !animChanged) {
            playerParts->curAnimation = get_player_anim_for_status(STATUS_KEY_STATIC);
            animChanged = TRUE;
        }
        if ((player->transparentStatus == STATUS_KEY_TRANSPARENT) || (playerParts->flags & ACTOR_PART_FLAG_TRANSPARENT)) {
            if (!animChanged) {
                playerParts->curAnimation = get_player_anim_for_status(STATUS_KEY_TRANSPARENT);
                animChanged = TRUE;
            }
            create_status_transparent(player->hudElementDataIndex, STATUS_KEY_TRANSPARENT);
        }
        if (!animChanged) {
            playerParts->curAnimation = get_player_anim_for_status(STATUS_KEY_NORMAL);
        }
    }
 
    if (!(gBattleStatus.flags1 & BS_FLAGS1_TATTLE_OPEN) && (player->flags & ACTOR_FLAG_SHOW_STATUS_ICONS)) {
        if (!cond4) {
            if (player->debuff == STATUS_KEY_POISON) {
                create_status_debuff(player->hudElementDataIndex, STATUS_KEY_POISON);
            } else if (player->debuff == STATUS_KEY_SLEEP) {
                create_status_debuff(player->hudElementDataIndex, STATUS_KEY_SLEEP);
            } else if (player->debuff == STATUS_KEY_PARALYZE) {
                create_status_debuff(player->hudElementDataIndex, STATUS_KEY_PARALYZE);
            } else if (player->debuff == STATUS_KEY_DIZZY) {
                create_status_debuff(player->hudElementDataIndex, STATUS_KEY_DIZZY);
            } else if (player->debuff == STATUS_KEY_SHRINK) {
                create_status_debuff(player->hudElementDataIndex, STATUS_KEY_SHRINK);
            } else if (player->debuff == STATUS_KEY_FROZEN) {
                create_status_debuff(player->hudElementDataIndex, STATUS_KEY_FROZEN);
            }
            if (is_ability_active(ABILITY_ZAP_TAP) || (player->staticStatus == STATUS_KEY_STATIC)) {
                create_status_static(player->hudElementDataIndex, STATUS_KEY_STATIC);
            }
        }
        if ((player->transparentStatus == STATUS_KEY_TRANSPARENT) || (playerParts->flags & ACTOR_PART_FLAG_TRANSPARENT)) {
            create_status_transparent(player->hudElementDataIndex, STATUS_KEY_TRANSPARENT);
        }
    } else {
        enable_status_debuff(player->hudElementDataIndex);
        enable_status_static(player->hudElementDataIndex);
        enable_status_transparent(player->hudElementDataIndex);
        enable_status_chill_out(player->hudElementDataIndex);
    }
 
    if (player->debuff != STATUS_KEY_STOP) {
        if (!animChanged) {
            s32 temp = playerParts->curAnimation;
            if (temp == get_player_anim_for_status(STATUS_KEY_STOP)) {
                playerParts->curAnimation = get_player_anim_for_status(STATUS_KEY_NORMAL);
            }
        }
    } else {
        playerParts->curAnimation = get_player_anim_for_status(STATUS_KEY_STOP);
        create_status_debuff(player->hudElementDataIndex, STATUS_KEY_STOP);
    }
 
end:
    set_status_icons_properties(player->hudElementDataIndex,
        playerPosX, playerPosY, playerPosZ,
        player->actorBlueprint->statusIconOffset.x * player->scalingFactor,
        player->actorBlueprint->statusIconOffset.y * player->scalingFactor,
        player->actorBlueprint->statusTextOffset.x * player->scalingFactor,
        player->actorBlueprint->statusTextOffset.y * player->scalingFactor);
    set_status_icons_offset(player->hudElementDataIndex,
        player->size.y * player->scalingFactor,
        player->size.x * player->scalingFactor);
 
    playerPosX += playerParts->palAnimPosOffset[0];
    playerPosY += playerParts->palAnimPosOffset[1];
 
    playerParts->curPos.x = playerPosX;
    playerParts->curPos.y = playerPosY;
    playerParts->curPos.z = playerPosZ;
    guTranslateF(mtxTranslate, playerPosX, playerPosY, playerPosZ);
 
    guTranslateF(mtxPivotOn,
        -player->rotPivotOffset.x * player->scalingFactor,
        -player->rotPivotOffset.y * player->scalingFactor,
        -player->rotPivotOffset.z * player->scalingFactor);
    guTranslateF(mtxPivotOff,
        player->rotPivotOffset.x * player->scalingFactor,
        player->rotPivotOffset.y * player->scalingFactor,
        player->rotPivotOffset.z * player->scalingFactor);
 
    guRotateF(mtxRotX, player->rot.x, 1.0f, 0.0f, 0.0f);
    guRotateF(mtxRotY, player->rot.y, 0.0f, 1.0f, 0.0f);
    guRotateF(mtxRotZ, player->rot.z, 0.0f, 0.0f, 1.0f);
    guMtxCatF(mtxRotY, mtxRotX, mtxTemp);
    guMtxCatF(mtxTemp, mtxRotZ, mtxRotation);
 
    guScaleF(mtxScale,
        player->scale.x * SPRITE_WORLD_SCALE_D * player->scalingFactor,
        player->scale.y * SPRITE_WORLD_SCALE_D * player->scalingFactor * playerParts->verticalStretch,
        player->scale.z * SPRITE_WORLD_SCALE_D);
 
    guMtxCatF(mtxScale, mtxPivotOn, mtxTemp);
    guMtxCatF(mtxTemp, mtxRotation, mtxTransform);
    guMtxCatF(mtxTransform, mtxPivotOff, mtxTemp);
    guMtxCatF(mtxTemp, mtxTranslate, mtxTransform);
 
    if (lastAnim != playerParts->curAnimation) {
        spr_update_player_sprite(PLAYER_SPRITE_MAIN, playerParts->curAnimation, playerParts->animationRate);
    }
    update_part_glow(FALSE, playerParts, clamp_angle(playerYaw + 180.0f), FALSE);
    update_part_flash(FALSE, playerParts, clamp_angle(playerYaw + 180.0f), FALSE);
    render_with_adjusted_palettes(SPRITE_MODE_PLAYER, playerParts, clamp_angle(playerYaw + 180.0f), mtxTransform, 0);
    _add_part_decoration(playerParts);
}

Referenced by btl_render_actors().

◆ appendGfx_player_actor_blur()

void appendGfx_player_actor_blur ( Actor * actor )

Definition at line 380 of file actor_rendering.c.

                                               {
    Matrix4f mtxRotX, mtxRotY, mtxRotZ, mtxRotation;
    Matrix4f mtxScale;
    Matrix4f mtxPivotOn, mtxPivotOff, mtxTranslate;
    Matrix4f mtxTransform, mtxTemp;
    s32 strideIdx;
    s32 drawIdx;
    s32 yaw;
    ActorPart* partTable;
    DecorationTable* decorations;
    f32 rotX, rotY, rotZ;
    s32 prevOpacity;
    s32 opacity;
    s32 pivotOffsetX;
    s32 pivotOffsetY;
    s32 bufPos;
    s32 blurOpacityBase;
    s32 opacityLossIncrement;
    f32 x, y, z;
 
    partTable = actor->partsTable;
    decorations = partTable->decorationTable;
    if (decorations->blurDisableDelay != 0) {
        decorations->blurDisableDelay--;
        if (decorations->blurDisableDelay == 0) {
            actor->flags &= ~ACTOR_FLAG_BLUR_ENABLED;
            return;
        }
    }
 
    if (!(partTable->flags & ACTOR_PART_FLAG_INVISIBLE) && partTable->idleAnimations != NULL) {
        bufPos = decorations->blurBufferPos;
        strideIdx = 0;
        drawIdx = 0;
 
        while (TRUE) {
            bufPos--;
            strideIdx++;
            if (bufPos < 0) {
                bufPos = ARRAY_COUNT(decorations->posX) - 1;
            }
            if (bufPos == decorations->blurBufferPos) {
                break;
            }
 
            // only draw every third blur frame
            if (strideIdx < 3) {
                continue;
            }
 
            strideIdx = 0;
            drawIdx++;
 
            if (decorations->blurDrawCount < drawIdx) {
                break;
            }
 
            opacity = partTable->opacity;
 
            x = decorations->posX[bufPos];
            y = decorations->posY[bufPos];
            z = decorations->posZ[bufPos];
 
            yaw = decorations->yaw[bufPos];
 
            pivotOffsetX = decorations->rotPivotOffsetX[bufPos];
            pivotOffsetY = decorations->rotPivotOffsetY[bufPos];
 
            rotX = decorations->rotX[bufPos] * 2;
            rotY = decorations->rotY[bufPos] * 2;
            rotZ = decorations->rotZ[bufPos] * 2;
 
            blurOpacityBase = 120;
            opacityLossIncrement = 20;
            if (opacity < 50) {
                blurOpacityBase = 50;
                opacityLossIncrement = 8;
            } else if (opacity < 100) {
                blurOpacityBase = 70;
                opacityLossIncrement = 10;
            } else if (opacity < 150) {
                blurOpacityBase = 100;
                opacityLossIncrement = 15;
            }
 
            guTranslateF(mtxTranslate, x, y, z);
            guTranslateF(mtxPivotOn, -pivotOffsetX, -pivotOffsetY, 0.0f);
            guTranslateF(mtxPivotOff, pivotOffsetX, pivotOffsetY, 0.0f);
            guRotateF(mtxRotX, rotX, 1.0f, 0.0f, 0.0f);
            guRotateF(mtxRotY, rotY, 0.0f, 1.0f, 0.0f);
            guRotateF(mtxRotZ, rotZ, 0.0f, 0.0f, 1.0f);
            guMtxCatF(mtxRotX, mtxRotY, mtxTransform);
            guMtxCatF(mtxTransform, mtxRotZ, mtxRotation);
            guScaleF(mtxScale, actor->scale.x * SPRITE_WORLD_SCALE_D * actor->scalingFactor,
                            actor->scale.y * SPRITE_WORLD_SCALE_D * actor->scalingFactor * partTable->verticalStretch,
                            actor->scale.z * SPRITE_WORLD_SCALE_D);
            guMtxCatF(mtxScale, mtxPivotOn, mtxTemp);
            guMtxCatF(mtxTemp, mtxRotation, mtxTransform);
            guMtxCatF(mtxTransform, mtxPivotOff, mtxTemp);
            guMtxCatF(mtxTemp, mtxTranslate, mtxTransform);
            prevOpacity = partTable->opacity;
            partTable->opacity = blurOpacityBase - (drawIdx * opacityLossIncrement);
            render_with_adjusted_palettes(SPRITE_MODE_PLAYER, partTable, clamp_angle(yaw + 180), mtxTransform, 1);
            partTable->opacity = prevOpacity;
        }
    }
}

Referenced by btl_render_actors().

◆ appendGfx_player_actor_reflection()

void appendGfx_player_actor_reflection ( void * arg0 )

Definition at line 1877 of file actor_rendering.c.

                                                   {
    Matrix4f mtxRotX, mtxRotY, mtxRotZ, mtxRotation, mtxScale;
    Matrix4f mtxPivotOn, mtxPivotOff, mtxTranslate;
    Matrix4f mtxTemp, mtxTransform, mtxMirror;
    Actor* player = gBattleStatus.playerActor;
    ActorPart* part = &player->partsTable[0];
    f32 playerYaw = player->yaw;
    f32 dx, dy, dz;
 
    dx = player->curPos.x + player->headOffset.x;
    dx += part->palAnimPosOffset[0];
    dy = player->curPos.y + player->headOffset.y;
    dy += part->palAnimPosOffset[1];
    dz = player->curPos.z + player->headOffset.z - 5.0f;
    part->yaw = playerYaw;
 
    guTranslateF(mtxTranslate, dx, dy, dz - 1.0f);
 
    guTranslateF(mtxPivotOn,
        -player->rotPivotOffset.x * player->scalingFactor,
        -player->rotPivotOffset.y * player->scalingFactor,
        -player->rotPivotOffset.z * player->scalingFactor);
    guTranslateF(mtxPivotOff,
        player->rotPivotOffset.x * player->scalingFactor,
        player->rotPivotOffset.y * player->scalingFactor,
        player->rotPivotOffset.z * player->scalingFactor);
 
    guRotateF(mtxRotX, player->rot.x, 1.0f, 0.0f, 0.0f);
    guRotateF(mtxRotY, player->rot.y, 0.0f, 1.0f, 0.0f);
    guRotateF(mtxRotZ, player->rot.z, 0.0f, 0.0f, 1.0f);
    guMtxCatF(mtxRotY, mtxRotX, mtxTemp);
    guMtxCatF(mtxTemp, mtxRotZ, mtxRotation);
    guScaleF(mtxScale,
        player->scale.x * SPRITE_WORLD_SCALE_D * player->scalingFactor,
        player->scale.y * SPRITE_WORLD_SCALE_D * player->scalingFactor * part->verticalStretch,
        player->scale.z * SPRITE_WORLD_SCALE_D);
    mtx_mirror_y(mtxMirror);
 
    guMtxCatF(mtxScale, mtxPivotOn, mtxTemp);
    guMtxCatF(mtxTemp, mtxRotation, mtxTemp);
    guMtxCatF(mtxTemp, mtxPivotOff, mtxTemp);
    guMtxCatF(mtxTemp, mtxTranslate, mtxTransform);
    guMtxCatF(mtxTransform, mtxMirror, mtxTransform);
 
    update_part_glow(FALSE, part, clamp_angle(playerYaw + 180.0f), TRUE);
    update_part_flash(FALSE, part, clamp_angle(playerYaw + 180.0f), TRUE);
    render_with_adjusted_palettes(SPRITE_MODE_PLAYER, part, clamp_angle(playerYaw + 180.0f), mtxTransform, TRUE);
}

Referenced by btl_render_actors().

◆ force_disable_actor_blur()

void force_disable_actor_blur ( Actor * actor )

Definition at line 254 of file actor_rendering.c.

                                            {
    ActorPart* actorPart = actor->partsTable;
 
    if (actorPart->idleAnimations != NULL && !(actorPart->flags & ACTOR_PART_FLAG_NO_DECORATIONS)) {
        DecorationTable* decorations = actorPart->decorationTable;
 
        decorations->blurEnableCount = 0;
        decorations->blurDisableDelay = 20;
    }
}

Referenced by force_disable_partner_blur().

◆ player_handle_floor_collider_type()

void player_handle_floor_collider_type ( s32 colliderID )

Definition at line 326 of file 7BB60.c.

                                                       {
    PlayerStatus* playerStatus = &gPlayerStatus;
    PartnerStatus* partnerStatus = &gPartnerStatus;
 
    if (colliderID > NO_COLLIDER) {
        s32 surfaceType = get_collider_flags(colliderID) & COLLIDER_FLAGS_SURFACE_TYPE_MASK;
        switch (surfaceType) {
            case SURFACE_TYPE_WATER:
            case SURFACE_TYPE_DOCK_WALL:
            case SURFACE_TYPE_SLIDE:
                set_action_state(ACTION_STATE_LAND);
                break;
            case SURFACE_TYPE_LAVA:
                if ((*(s32*)(&partnerStatus->partnerActionState) & 0xFF0000FF) != 0x01000009) {
                    if (playerStatus->blinkTimer == 0) {
                        if (playerStatus->actionState != ACTION_STATE_HIT_LAVA) {
                            playerStatus->hazardType = HAZARD_TYPE_LAVA;
                            set_action_state(ACTION_STATE_HIT_LAVA);
                        }
                    } else {
                        set_action_state(ACTION_STATE_KNOCKBACK);
                    }
                }
                break;
            case SURFACE_TYPE_SPIKES:
                if ((*(s32*)(&partnerStatus->partnerActionState) & 0xFF0000FF) != 0x01000009) {
                    if (playerStatus->blinkTimer == 0) {
                        if (playerStatus->actionState != ACTION_STATE_HIT_FIRE) {
                            playerStatus->hazardType = HAZARD_TYPE_SPIKES;
                            set_action_state(ACTION_STATE_HIT_LAVA);
                        }
                        break;
                    }
                    set_action_state(ACTION_STATE_KNOCKBACK);
                }
                break;
            default:
                phys_player_land();
                break;
        }
    }
}

Referenced by handle_jumping_land_on_switch(), phys_update_falling(), and player_jump().

◆ player_fall_distance()

f32 player_fall_distance ( void )

Definition at line 461 of file 7BB60.c.

                               {
    f32 velocity = integrate_gravity();
 
    if (check_player_action_debug()) {
        velocity = 0.0f;
    }
    return velocity;
}

Referenced by action_update_hit_fire(), action_update_hit_lava(), action_update_knockback(), action_update_sliding(), action_update_spin_jump(), handle_jumping_land_on_switch(), and phys_update_falling().

◆ func_800E4AD8()

void func_800E4AD8 ( s32 arg0 )

Definition at line 978 of file 7BB60.c.

                             {
    f32 camYaw = gCameras[gCurrentCameraID].curYaw;
 
    collision_check_player_intersecting_world(mode, 0, gPlayerStatus.spriteFacingAngle - 90.0f + camYaw);
}

◆ player_check_collision_below()

f32 player_check_collision_below	(	f32	offset,
		s32 *	colliderID )

Definition at line 470 of file 7BB60.c.

                                                              {
    PlayerStatus* playerStatus = &gPlayerStatus;
    CollisionStatus* collisionStatus = &gCollisionStatus;
    f32 temp_f4 = playerStatus->colliderHeight * 0.5f;
    f32 outLength = fabsf(offset) + temp_f4;
    f32 x = playerStatus->pos.x;
    f32 y = playerStatus->pos.y + temp_f4;
    f32 z = playerStatus->pos.z;
    f32 sp38, sp3C, sp40, sp44;
    s32 hit = *colliderID = player_raycast_below_cam_relative(&gPlayerStatus, &x, &y, &z, &outLength,
                                                              &sp38, &sp3C, &sp40, &sp44);
 
    if (hit <= NO_COLLIDER) {
        if (offset >= 0.0f && collisionStatus->curCeiling > NO_COLLIDER) {
            return playerStatus->pos.y;
        }
        y = playerStatus->pos.y + offset;
    } else {
        collisionStatus->curFloor = hit;
        collisionStatus->lastTouchedFloor = -1;
    }
    return y;
}

Referenced by action_update_hit_fire(), action_update_hit_lava(), action_update_knockback(), action_update_sliding(), action_update_spin_jump(), action_update_step_up(), action_update_tornado_jump(), action_update_use_munchlesia(), action_update_use_spinning_flower(), handle_jumping_land_on_switch(), phys_update_falling(), and player_jump().

◆ can_trigger_loading_zone()

b32 can_trigger_loading_zone ( void )

Definition at line 22 of file 7BB60.c.

                                   {
    PlayerData* playerData = &gPlayerData;
    s32 actionState = gPlayerStatusPtr->actionState;
    PartnerStatus* partnerStatus = &gPartnerStatus;
 
    if (actionState == ACTION_STATE_IDLE ||
        actionState == ACTION_STATE_WALK ||
        actionState == ACTION_STATE_RUN ||
        actionState == ACTION_STATE_USE_TWEESTER ||
        actionState == ACTION_STATE_SPIN
       ) {
        return TRUE;
    }
 
    if (actionState == ACTION_STATE_RIDE) {
        if (playerData->curPartner == PARTNER_LAKILESTER || playerData->curPartner == PARTNER_BOW) {
            if (partnerStatus->partnerActionState != PARTNER_ACTION_NONE) {
                return TRUE;
            } else {
                gPlayerStatusPtr->animFlags |= PA_FLAG_INTERRUPT_USE_PARTNER;
                return FALSE;
            }
        } else {
            if (partnerStatus->actingPartner == PARTNER_WATT || partnerStatus->actingPartner == PARTNER_SUSHIE) {
                return partnerStatus->partnerActionState != PARTNER_ACTION_NONE;
            }
            if (partnerStatus->actingPartner == PARTNER_PARAKARRY) {
                gPlayerStatusPtr->animFlags |= PA_FLAG_INTERRUPT_USE_PARTNER;
                return FALSE;
            }
        }
    }
    return FALSE;
}

◆ update_damage_popups()

void update_damage_popups ( void )

Definition at line 2320 of file 190B20.c.

                                {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gDamageCountEffects); i++) {
        if (gDamageCountEffects[i] != NULL) {
            gDamageCountTimers[i]--;
            if (gDamageCountTimers[i] == 0) {
                gDamageCountEffects[i]->data.damageIndicator->timeLeft = 5;
                gDamageCountEffects[i] = NULL;
            }
        }
    };
}

Referenced by btl_update().

◆ show_action_rating()

void show_action_rating	(	s32	rating,
		Actor *	actor,
		f32	x,
		f32	y,
		f32	z )

Definition at line 2360 of file 190B20.c.

                                                                       {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player;
    s32 new_var; // TODO required to match
    s32 type;
 
    actor->attackResultEffect = actor->attackResultEffect; // TODO required to match
    player = battleStatus->playerActor;
 
    if (actor->attackResultEffect == NULL) {
        type = 0;
        switch (rating) {
            case ACTION_RATING_NICE:
                type = 0;
                actor->actionRatingCombo = 1;
                break;
            case ACTION_RATING_MISS:
                type = 4;
                actor->actionRatingCombo = 0;
                break;
            case ACTION_RATING_LUCKY:
                type = 3;
                actor->actionRatingCombo = 0;
                break;
            case ACTION_RATING_SUPER:
                type = 2;
                actor->actionRatingCombo = 2;
                break;
            case ACTION_RATING_NICE_NO_COMBO:
                type = 0;
                actor->actionRatingCombo = 0;
                break;
            case ACTION_RATING_NICE_SUPER_COMBO:
                type = player->actionRatingCombo;
                player->actionRatingCombo++;
                if (player->actionRatingCombo > 2) {
                    player->actionRatingCombo = 2;
                }
                break;
        }
        actor->attackResultEffect = fx_attack_result_text(type, x, y, z - 10.0f, 12.0f, 90);
        actor->actionRatingTime = 80;
        new_var = 2; // TODO required to match
    } else {
        actor->attackResultEffect->data.attackResultText->timeLeft = 0;
        type = actor->actionRatingCombo;
        new_var = rating; // TODO required to match
        switch (new_var) { // TODO required to match
            case ACTION_RATING_NICE:
                actor->actionRatingCombo++;
                if (actor->actionRatingCombo > 2) {
                    actor->actionRatingCombo = 2;
                }
                break;
            case ACTION_RATING_MISS:
                type = 4;
                break;
            case ACTION_RATING_LUCKY:
                type = 3;
                break;
            case ACTION_RATING_SUPER:
                type = 2;
                break;
            case ACTION_RATING_NICE_NO_COMBO:
                type = 0;
                break;
            case ACTION_RATING_NICE_SUPER_COMBO:
                type = player->actionRatingCombo;
                player->actionRatingCombo++;
                if (player->actionRatingCombo > 2) {
                    player->actionRatingCombo = 2;
                }
                break;
        }
        actor->attackResultEffect = fx_attack_result_text(type, x, y, z - 10.0f, 12.0f, 90);
        actor->actionRatingTime = 80;
    }
}

Referenced by calc_enemy_damage_target(), calc_item_damage_enemy(), calc_partner_damage_enemy(), and calc_player_damage_enemy().

◆ render_with_adjusted_palettes()

s32 render_with_adjusted_palettes	(	s32	isNpcSprite,
		ActorPart *	part,
		s32	yaw,
		Matrix4f	mtx,
		s32	skipAnimation )

Definition at line 1926 of file actor_rendering.c.

                                                                                                              {
    s32 opacity;
    s32 sprDrawOpts;
 
    if (part->flags & ACTOR_PART_FLAG_NO_DECORATIONS) {
        opacity = 255;
        sprDrawOpts = 0;
        if (part->opacity < 255) {
            sprDrawOpts = DRAW_SPRITE_OVERRIDE_ALPHA;
            opacity = part->opacity;
        }
        if (part->flags & ACTOR_PART_FLAG_TRANSPARENT) {
            sprDrawOpts = DRAW_SPRITE_OVERRIDE_ALPHA;
            opacity = opacity * 120 / 255;
        }
        if (isNpcSprite == SPRITE_MODE_PLAYER) {
            if (opacity == 255) {
                spr_draw_player_sprite(PLAYER_SPRITE_MAIN, yaw, 0, NULL, mtx);
            } else {
                spr_draw_player_sprite(PLAYER_SPRITE_MAIN | sprDrawOpts, yaw, opacity, NULL, mtx);
            }
        } else {
            if (opacity == 255) {
                spr_draw_npc_sprite(part->spriteInstanceID, yaw, 0, NULL, mtx);
            } else {
                spr_draw_npc_sprite(part->spriteInstanceID | sprDrawOpts, yaw, opacity, NULL, mtx);
            }
        }
        return 0;
    }
 
    switch (part->decorationTable->paletteAdjustment) {
        case ACTOR_PAL_ADJUST_NONE:
            render_without_adjusted_palettes(isNpcSprite, part, yaw, mtx, skipAnimation);
            break;
        case ACTOR_PAL_ADJUST_SLEEP:
            render_with_sleep_palettes(isNpcSprite, part, yaw, mtx, skipAnimation);
            break;
        case ACTOR_PAL_ADJUST_STATIC:
            render_with_static_palettes(isNpcSprite, part, yaw, mtx, skipAnimation);
            break;
        case ACTOR_PAL_ADJUST_FEAR:
            render_with_fear_palettes(isNpcSprite, part, yaw, mtx, skipAnimation);
            break;
        case ACTOR_PAL_ADJUST_POISON:
            render_with_poison_palettes(isNpcSprite, part, yaw, mtx, skipAnimation);
            break;
        case ACTOR_PAL_ADJUST_PARALYZE:
            render_with_paralyze_palettes(isNpcSprite, part, yaw, mtx, skipAnimation);
            break;
        case ACTOR_PAL_ADJUST_BERSERK:
            render_with_berserk_palettes(isNpcSprite, part, yaw, mtx, skipAnimation);
            break;
        case ACTOR_PAL_ADJUST_WATT_IDLE:
            render_with_watt_idle_palettes(isNpcSprite, part, yaw, mtx, skipAnimation);
            break;
        case ACTOR_PAL_ADJUST_WATT_ATTACK:
            render_with_watt_attack_palettes(isNpcSprite, part, yaw, mtx, skipAnimation);
            break;
        case ACTOR_PAL_ADJUST_PLAYER_DEBUFF:
            render_with_player_debuff_palettes(isNpcSprite, part, yaw, mtx, skipAnimation, FALSE);
            break;
        case ACTOR_PAL_ADJUST_PLAYER_POISON:
            render_with_player_debuff_palettes(isNpcSprite, part, yaw, mtx, skipAnimation, TRUE);
            break;
        case ACTOR_PAL_ADJUST_BLEND_PALETTES_UNIFORM_INTERVALS:
            render_with_pal_blending(isNpcSprite, part, yaw, FALSE, mtx, skipAnimation);
            break;
        case ACTOR_PAL_ADJUST_BLEND_PALETTES_VARYING_INTERVALS:
            render_with_pal_blending(isNpcSprite, part, yaw, TRUE, mtx, skipAnimation);
            break;
        case ACTOR_PAL_ADJUST_BLEND_PALSETS:
            render_with_palset_blending(isNpcSprite, part, yaw, mtx, skipAnimation);
            break;
        default:
            break;
    }
    return 0;
}

Referenced by appendGfx_npc_actor(), appendGfx_npc_actor_reflection(), appendGfx_player_actor(), appendGfx_player_actor_blur(), and appendGfx_player_actor_reflection().

◆ general_heap_create()

HeapNode * general_heap_create ( void )

Definition at line 6 of file heap.c.

                                    {
    return _heap_create(&heap_generalHead, GENERAL_HEAP_SIZE);
}

Referenced by general_heap_create_obfuscated(), load_demo_battle(), load_engine_data(), state_init_file_select(), state_init_logos(), state_init_title_screen(), state_step_demo(), state_step_intro(), state_step_startup(), and state_step_title_screen().

◆ general_heap_malloc()

void * general_heap_malloc ( s32 size )

Definition at line 10 of file heap.c.

                                    {
    return _heap_malloc(&heap_generalHead, size);
}

◆ general_heap_free()

s32 general_heap_free ( void * data )

Definition at line 18 of file heap.c.

                                  {
    return _heap_free(&heap_generalHead, data);
}

Referenced by _update_message(), btl_state_update_normal_start(), draw_msg(), func_8013A4D0(), get_msg_properties(), heap_free(), imgfx_update_cache_impl(), init_hud_element_list(), load_battle_hit_asset(), load_map_bg(), load_map_by_IDs(), load_map_hit_asset(), pause_partners_load_portrait(), remove_all_effects(), remove_effect(), restore_map_collision_data(), set_message_text_var(), spr_load_sprite(), state_init_title_screen(), state_step_end_battle(), state_step_unpause(), update_effects(), update_model_animator(), and update_model_animator_with_transform().

◆ integer_log()

s32 integer_log	(	s32	number,
		u32	base )

Definition at line 302 of file draw_img_util.c.

                                      {
    f32 fNumber = number;
    s32 ret = 1;
 
    while (TRUE) {
        fNumber /= base;
        if (fNumber <= 1.0) {
            return ret;
        }
 
        ret++;
    }
}

Referenced by draw_adjustable_tiled_image(), and imgfx_appendGfx_mesh_strip().

◆ set_battle_stage()

void set_battle_stage ( s32 stageID )

Definition at line 138 of file battle.c.

                                   {
    gCurrentStageID = stageID;
}

Referenced by load_demo_battle(), and update_encounters_pre_battle().

◆ load_battle()

void load_battle ( s32 battleID )

Definition at line 130 of file battle.c.

                               {
    gCurrentBattleID = battleID;
    set_game_mode(GAME_MODE_BATTLE);
    gBattleState = BATTLE_STATE_0;
    gLastDrawBattleState = BATTLE_STATE_0;
    gBattleSubState = BTL_SUBSTATE_INIT;
}

Referenced by load_demo_battle(), and update_encounters_pre_battle().

◆ entity_Shadow_init()

void entity_Shadow_init ( Shadow * entity )

Definition at line 5 of file Shadow.c.

                                        {
    shadow->scale.x = 0.1f;
    shadow->scale.y = 0.1f;
    shadow->scale.z = 0.1f;
}

◆ entity_SaveBlock_idle()

void entity_SaveBlock_idle ( Entity * entity )

Definition at line 80 of file SaveBlock.c.

                                           {
    SaveBlockData* data;
 
    data = entity->dataBuf.saveBlock;
    data->angle = clamp_angle(data->angle + 6);
    entity_base_block_idle(entity);
}

◆ entity_SaveBlock_pause_game()

void entity_SaveBlock_pause_game ( void )

Definition at line 88 of file SaveBlock.c.

                                       {
    set_time_freeze_mode(TIME_FREEZE_PARTIAL);
    disable_player_input();
    gPlayerStatusPtr->curSpeed = 0.0f;
}

◆ entity_SaveBlock_resume_game()

void entity_SaveBlock_resume_game ( void )

Definition at line 94 of file SaveBlock.c.

                                        {
    set_time_freeze_mode(TIME_FREEZE_NONE);
    enable_player_input();
}

◆ entity_SaveBlock_save_data()

void entity_SaveBlock_save_data ( void )

Definition at line 99 of file SaveBlock.c.

                                      {
    gGameStatusPtr->savedPos.x = gPlayerStatusPtr->pos.x;
    gGameStatusPtr->savedPos.y = gPlayerStatusPtr->pos.y;
    gGameStatusPtr->savedPos.z = gPlayerStatusPtr->pos.z;
    fio_save_game(gGameStatusPtr->saveSlot);
}

◆ entity_SaveBlock_show_tutorial_message()

void entity_SaveBlock_show_tutorial_message ( Entity * entity )

Definition at line 106 of file SaveBlock.c.

                                                            {
    if (!get_global_flag(GF_Tutorial_SaveBlock)) {
        SaveBlockTutorialPrinterClosed = FALSE;
        msg_get_printer_for_msg(MSG_Menus_Tutorial_SaveBlock, &SaveBlockTutorialPrinterClosed);
        set_global_flag(GF_Tutorial_SaveBlock);
        return;
    }
 
    exec_entity_commandlist(entity);
    exec_entity_commandlist(entity);
}

◆ entity_SaveBlock_wait_for_close_tutorial()

void entity_SaveBlock_wait_for_close_tutorial ( Entity * entity )

Definition at line 118 of file SaveBlock.c.

                                                              {
    if (SaveBlockTutorialPrinterClosed) {
        exec_entity_commandlist(entity);
    }
}

◆ entity_SaveBlock_show_choice_message()

void entity_SaveBlock_show_choice_message ( void )

Definition at line 124 of file SaveBlock.c.

                                                {
    SaveBlockTutorialPrinterClosed = FALSE;
    SaveBlockResultPrinterClosed = FALSE;
    SaveBlockResultPrinter = msg_get_printer_for_msg(MSG_Menus_SavePrompt, &SaveBlockResultPrinterClosed);
    SaveBlockTutorialPrinter = msg_get_printer_for_msg(MSG_Choice_000A, &SaveBlockTutorialPrinterClosed);
}

◆ entity_SaveBlock_show_result_message()

void entity_SaveBlock_show_result_message ( void )

Definition at line 131 of file SaveBlock.c.

                                                {
    msg_printer_load_msg(MSG_Menus_SaveComplete, SaveBlockResultPrinter);
    sfx_play_sound(SOUND_SAVE_CONFIRM);
}

◆ entity_SaveBlock_wait_for_close_result()

void entity_SaveBlock_wait_for_close_result ( Entity * entity )

Definition at line 136 of file SaveBlock.c.

                                                            {
    if (SaveBlockResultPrinterClosed) {
        exec_entity_commandlist(entity);
    }
}

◆ entity_SaveBlock_wait_for_close_choice()

void entity_SaveBlock_wait_for_close_choice ( Entity * entity )

Definition at line 142 of file SaveBlock.c.

                                                            {
    if (SaveBlockTutorialPrinterClosed) {
        if (SaveBlockTutorialPrinter->curOption == 1) {
            set_entity_commandlist(entity, Entity_SaveBlock_ScriptResume);
        } else {
            exec_entity_commandlist(entity);
        }
        close_message(SaveBlockResultPrinter);
    }
}

◆ entity_SaveBlock_init()

void entity_SaveBlock_init ( Entity * entity )

Definition at line 153 of file SaveBlock.c.

                                           {
    SaveBlockData* data = entity->dataBuf.saveBlock;
 
    entity_base_block_init(entity);
    entity->renderSetupFunc = entity_SaveBlock_setupGfx;
    data->angle = 8;
}

◆ entity_GreenStompSwitch_idle()

void entity_GreenStompSwitch_idle ( Entity * entity )

Definition at line 25 of file Switch.c.

                                                  {
    PlayerStatus* playerStatus = &gPlayerStatus;
    SwitchData* data = entity->dataBuf.swtch;
 
    if (entity->collisionFlags & ENTITY_COLLISION_PLAYER_TOUCH_FLOOR) {
        if ((playerStatus->actionState == ACTION_STATE_SPIN_POUND)
            || (playerStatus->actionState == ACTION_STATE_TORNADO_POUND)) {
            exec_entity_commandlist(entity);
            data->greenMotionTimer = 8;
        }
    }
}

◆ entity_GreenStompSwitch_retract()

void entity_GreenStompSwitch_retract ( Entity * entity )

Definition at line 38 of file Switch.c.

                                                     {
    SwitchData* data = entity->dataBuf.swtch;
    u16 curTime = data->greenMotionTimer--;
 
    if (curTime != 0) {
        entity->pos.y -= 1.8625;
        return;
    }
    entity_start_script(entity);
    exec_entity_commandlist(entity);
    data->greenMotionTimer = 8;
}

◆ entity_GreenStompSwitch_extend()

void entity_GreenStompSwitch_extend ( Entity * entity )

Definition at line 51 of file Switch.c.

                                                    {
    SwitchData* data = entity->dataBuf.swtch;
    u16 curTime = data->greenMotionTimer--;
 
    if (curTime != 0) {
        entity->pos.y += 1.8625;
        return;
    }
    exec_entity_commandlist(entity);
    data->greenMotionTimer = 8;
}

◆ entity_HugeBlueSwitch_idle()

void entity_HugeBlueSwitch_idle ( Entity * entity )

Definition at line 86 of file Switch.c.

                                                {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    if (entity->collisionFlags & ENTITY_COLLISION_PLAYER_TOUCH_FLOOR) {
        if ((playerStatus->actionState == ACTION_STATE_SPIN_POUND)
            || (playerStatus->actionState == ACTION_STATE_TORNADO_POUND)) {
            exec_entity_commandlist(entity);
        }
    }
}

◆ entity_small_switch_idle()

void entity_small_switch_idle ( Entity * entity )

Definition at line 97 of file Switch.c.

                                              {
    SwitchData* data = entity->dataBuf.swtch;
    PlayerStatus* playerStatus = &gPlayerStatus;
    PartnerStatus* partnerStatus = &gPartnerStatus;
 
    entity_switch_fall_down(entity);
 
    if (entity->collisionFlags & ENTITY_COLLISION_PLAYER_HAMMER) {
        if (playerStatus->actionState == ACTION_STATE_HAMMER) {
            if (gPlayerData.hammerLevel < 0) {
                return;
            }
            exec_entity_commandlist(entity);
 
            if (data->linkedSwitch == NULL) {
                return;
            }
 
            exec_entity_commandlist(data->linkedSwitch);
            return;
        }
    }
 
    if (playerStatus->actionState == ACTION_STATE_SPIN_JUMP) {
        return;
    }
 
    if (partnerStatus->actingPartner == PARTNER_PARAKARRY && partnerStatus->partnerActionState != PARTNER_ACTION_NONE) {
        return;
    }
 
    if (!(entity->collisionFlags & ENTITY_COLLISION_PLAYER_TOUCH_FLOOR)) {
        if (!(entity->collisionFlags & ENTITY_COLLISION_PARTNER)) {
            return;
        }
    }
 
    exec_entity_commandlist(entity);
 
    if (data->linkedSwitch == NULL) {
        return;
    }
 
    exec_entity_commandlist(data->linkedSwitch);
}

◆ entity_RedSwitch_wait_and_reset()

void entity_RedSwitch_wait_and_reset ( Entity * entity )

Definition at line 143 of file Switch.c.

                                                     {
    if (!(entity->collisionFlags & ENTITY_COLLISION_PLAYER_TOUCH_FLOOR)) {
        exec_entity_commandlist(entity);
    }
}

◆ entity_base_switch_anim_init()

void entity_base_switch_anim_init ( Entity * entity )

Definition at line 149 of file Switch.c.

                                                  {
    SwitchData* data = entity->dataBuf.swtch;
 
    data->fallVel = 1.0f;
    data->deltaScaleX = 0.1f;
    data->deltaScaleY = -0.1f;
    data->animStateScaleX = 0;
    data->animStateScaleY = 0;
}

◆ entity_RedSwitch_animate_scale()

s32 entity_RedSwitch_animate_scale ( Entity * entity )

Definition at line 159 of file Switch.c.

                                                   {
    f32 phi_f4;
    f32 temp_f6;
    SwitchData* data = entity->dataBuf.swtch;
    s32 phi_s2 = 0;
 
    switch (data->animStateScaleX) {
        case 0:
            temp_f6 = data->baseScale.z * 0.3;
            phi_f4 = ((data->baseScale.x + temp_f6) - entity->scale.x) / 4.0;
            if (phi_f4 < 0.01) {
                phi_f4 = 0.01f;
            }
            data->deltaScaleX += phi_f4;
            entity->scale.x += data->deltaScaleX;
            if ((data->baseScale.x + temp_f6) <= entity->scale.x) {
                data->deltaScaleX = 0.0f;
                data->animStateScaleX++;
            }
            break;
        case 1:
            temp_f6 = data->baseScale.z * -0.2;
            phi_f4 = ((data->baseScale.x + temp_f6) - entity->scale.x) / 6.0;
            if (phi_f4 > -0.01) {
                phi_f4 = -0.01f;
            }
            data->deltaScaleX += phi_f4;
            entity->scale.x += data->deltaScaleX;
            if (entity->scale.x <= (data->baseScale.x + temp_f6)) {
                data->deltaScaleX = 0.0f;
                data->animStateScaleX++;
            }
            break;
        case 2:
            temp_f6 = data->baseScale.z * 0.15;
            phi_f4 = ((data->baseScale.x + temp_f6) - entity->scale.x) / 4.0;
            if (phi_f4 < 0.01) {
                phi_f4 = 0.01f;
            }
            data->deltaScaleX += phi_f4;
            entity->scale.x += data->deltaScaleX;
            if ((data->baseScale.x + temp_f6) <= entity->scale.x) {
                data->deltaScaleX = 0.0f;
                data->animStateScaleX++;
            }
            break;
        case 3:
            temp_f6 = data->baseScale.z * -0.1;
            phi_f4 = ((data->baseScale.x + temp_f6) - entity->scale.x) / 6.0;
            if (phi_f4 > -0.01) {
                phi_f4 = -0.01f;
            }
            data->deltaScaleX += phi_f4;
            entity->scale.x += data->deltaScaleX;
            if (entity->scale.x <= (data->baseScale.x + temp_f6)) {
                data->deltaScaleX = 0.0f;
                data->animStateScaleX++;
            }
            break;
        case 4:
            phi_f4 = (data->baseScale.x - entity->scale.x) / 4.0;
            if (phi_f4 < 0.01) {
                phi_f4 = 0.01f;
            }
            data->deltaScaleX += phi_f4;
            entity->scale.x += data->deltaScaleX;
            if (data->baseScale.x <= entity->scale.x) {
                entity->scale.x = data->baseScale.x;
                data->deltaScaleX = 0.0f;
                data->animStateScaleX++;
            }
            break;
        case 5:
            phi_s2++;
            break;
    }
 
    entity->scale.z = entity->scale.x;
 
    switch (data->animStateScaleY) {
        case 0:
            temp_f6 = data->baseScale.z * -0.5;
            phi_f4 = ((data->baseScale.y + temp_f6) - entity->scale.y) / 5.0;
            if (phi_f4 > -0.01) {
                phi_f4 = -0.01f;
            }
            data->deltaScaleY += phi_f4;
            entity->scale.y += data->deltaScaleY;
            if (entity->scale.y <= (data->baseScale.y + temp_f6)) {
                data->deltaScaleY = 0.0f;
                data->animStateScaleY++;
            }
            break;
        case 1:
            temp_f6 = data->baseScale.z * 0.1;
            phi_f4 = ((data->baseScale.y + temp_f6) - entity->scale.y) / 10.0;
            if (phi_f4 < 0.01) {
                phi_f4 = 0.01f;
            }
            data->deltaScaleY += phi_f4;
            entity->scale.y += data->deltaScaleY;
            if ((data->baseScale.y + temp_f6) <= entity->scale.y) {
                data->deltaScaleY = 0.0f;
                data->animStateScaleY++;
            }
            break;
        case 2:
            temp_f6 = data->baseScale.z * -0.3;
            phi_f4 = ((data->baseScale.y + temp_f6) - entity->scale.y) / 5.0;
            if (phi_f4 > -0.01) {
                phi_f4 = -0.01f;
            }
            data->deltaScaleY += phi_f4;
            entity->scale.y += data->deltaScaleY;
            if (entity->scale.y <= (data->baseScale.y + temp_f6)) {
                data->deltaScaleY = 0.0f;
                data->animStateScaleY++;
            }
            break;
        case 3:
            temp_f6 = data->baseScale.z * 0.0;
            phi_f4 = ((data->baseScale.y + temp_f6) - entity->scale.y) / 10.0;
            if (phi_f4 < 0.01) {
                phi_f4 = 0.01f;
            }
            data->deltaScaleY += phi_f4;
            entity->scale.y += data->deltaScaleY;
            if ((data->baseScale.y + temp_f6) <= entity->scale.y) {
                data->deltaScaleY = 0.0f;
                data->animStateScaleY++;
            }
            break;
        case 4:
            phi_f4 = (data->baseScale.y - entity->scale.y) / 5.0;
            if (phi_f4 > -0.01) {
                phi_f4 = -0.01f;
            }
            data->deltaScaleY += phi_f4;
            entity->scale.y += data->deltaScaleY;
            if (entity->scale.y <= data->baseScale.y) {
                entity->scale.y = data->baseScale.y;
                data->deltaScaleY = 0.0f;
                data->animStateScaleY++;
            }
            break;
        case 5:
            phi_s2++;
            break;
    }
 
    entity_switch_fall_down(entity);
    if (phi_s2 == 2) {
        data->animStateScaleX = 0;
        data->animStateScaleY = 0;
        exec_entity_commandlist(entity);
    }
}

◆ entity_base_switch_start_bound_script()

void entity_base_switch_start_bound_script ( Entity * entity )

Definition at line 317 of file Switch.c.

                                                           {
    SwitchData* data = entity->dataBuf.swtch;
    set_area_flag(data->areaFlagIndex);
    entity_start_script(entity);
}

◆ entity_base_switch_animate_scale()

void entity_base_switch_animate_scale ( Entity * entity )

Definition at line 323 of file Switch.c.

                                                      {
    f32 phi_f4;
    f32 scaleChange;
    SwitchData* data = entity->dataBuf.swtch;
    s32 phi_s2 = 0;
 
    switch (data->animStateScaleX) {
        case 0:
            scaleChange = data->baseScale.z * 0.3;
            phi_f4 = ((data->baseScale.x + scaleChange) - entity->scale.x) / 4.0;
            if (phi_f4 < 0.01) {
                phi_f4 = 0.01f;
            }
            data->deltaScaleX += phi_f4;
            entity->scale.x += data->deltaScaleX;
            if ((data->baseScale.x + scaleChange) <= entity->scale.x) {
                data->deltaScaleX = 0.0f;
                data->animStateScaleX++;
            }
            break;
        case 1:
            scaleChange = (data->baseScale.z * -0.2);
            phi_f4 = ((data->baseScale.x + scaleChange) - entity->scale.x) / 6.0;
            if (phi_f4 > -0.01) {
                phi_f4 = -0.01f;
            }
            data->deltaScaleX += phi_f4;
            entity->scale.x += data->deltaScaleX;
            if (entity->scale.x <= (data->baseScale.x + scaleChange)) {
                data->deltaScaleX = 0.0f;
                data->animStateScaleX++;
            }
            break;
        case 2:
            scaleChange = data->baseScale.z * 0.15;
            phi_f4 = ((data->baseScale.x + scaleChange) - entity->scale.x) / 4.0;
            if (phi_f4 < 0.01) {
                phi_f4 = 0.01f;
            }
            data->deltaScaleX += phi_f4;
            entity->scale.x += data->deltaScaleX;
            if ((data->baseScale.x + scaleChange) <= entity->scale.x) {
                data->deltaScaleX = 0.0f;
                data->animStateScaleX++;
            }
            break;
        case 3:
            scaleChange = data->baseScale.z * -0.1;
            phi_f4 = ((data->baseScale.x + scaleChange) - entity->scale.x) / 6.0;
            if (phi_f4 > -0.01) {
                phi_f4 = -0.01f;
            }
            data->deltaScaleX += phi_f4;
            entity->scale.x += data->deltaScaleX;
            if (entity->scale.x <= (data->baseScale.x + scaleChange)) {
                data->deltaScaleX = 0.0f;
                data->animStateScaleX++;
            }
            break;
        case 4:
            phi_s2++;
            break;
    }
 
    entity->scale.z = entity->scale.x;
 
    switch (data->animStateScaleY) {
        case 0:
            scaleChange = data->baseScale.z * -0.5;
            phi_f4 = ((data->baseScale.y + scaleChange) - entity->scale.y) / 5.0;
            if (phi_f4 > -0.01) {
                phi_f4 = -0.01f;
            }
            data->deltaScaleY += phi_f4;
            entity->scale.y += data->deltaScaleY;
            if (entity->scale.y <= (data->baseScale.y + scaleChange)) {
                data->deltaScaleY = 0.0f;
                data->animStateScaleY++;
            }
            break;
        case 1:
            scaleChange = data->baseScale.z * 0.1;
            phi_f4 = ((data->baseScale.y + scaleChange) - entity->scale.y) / 10.0;
            if (phi_f4 < 0.01) {
                phi_f4 = 0.01f;
            }
            data->deltaScaleY += phi_f4;
            entity->scale.y += data->deltaScaleY;
            if ((data->baseScale.y + scaleChange) <= entity->scale.y) {
                data->deltaScaleY = 0.0f;
                data->animStateScaleY++;
            }
            break;
        case 2:
            scaleChange = data->baseScale.z * -0.3;
            phi_f4 = ((data->baseScale.y + scaleChange) - entity->scale.y) / 5.0;
            if (phi_f4 > -0.01) {
                phi_f4 = -0.01f;
            }
            data->deltaScaleY += phi_f4;
            entity->scale.y += data->deltaScaleY;
            if (entity->scale.y <= (data->baseScale.y + scaleChange)) {
                data->deltaScaleY = 0.0f;
                data->animStateScaleY++;
            }
            break;
        case 3:
            phi_s2++;
            break;
    }
 
    entity_switch_fall_down(entity);
    if (phi_s2 == 2) {
        data->animStateScaleX = 0;
        data->animStateScaleY = 0;
        exec_entity_commandlist(entity);
    }
 
    data->scaleAnimTimer++;
    if (data->scaleAnimTimer == 10 && data->linkedSwitch == NULL) {
        fx_cold_breath(0, entity->pos.x, entity->pos.y, entity->pos.z, 1.0f, 60);
    }
}

◆ entity_base_switch_init()

void entity_base_switch_init ( Entity * entity )

Definition at line 447 of file Switch.c.

                                             {
    PlayerStatus* playerStatus = &gPlayerStatus;
    SwitchData* data = entity->dataBuf.swtch;
 
    playerStatus->animFlags |= PA_FLAG_MAP_HAS_SWITCH;
    data->baseScale.x = 1.0f;
    data->baseScale.y = 1.0f;
    data->baseScale.z = 1.0f;
}

Referenced by entity_BlueSwitch_init(), and entity_HugeBlueSwitch_init().

◆ entity_block_hit_init_scale()

f32 entity_block_hit_init_scale ( Entity * entity )

Definition at line 75 of file Block.c.

                                                {
    s32 type = get_entity_type(entity->listIndex);
    if (type == ENTITY_TYPE_HAMMER1_BLOCK_TINY || type == ENTITY_TYPE_HAMMER2_BLOCK_TINY || type == ENTITY_TYPE_HAMMER3_BLOCK_TINY) {
        entity->scale.y = 0.23f;
        entity->scale.x = 1.04f;
        entity->scale.z = 1.04f;
        entity->pos.y += 18.0f;
    } else {
        entity->scale.y = 0.46f;
        entity->scale.x = 2.08f;
        entity->scale.z = 2.08f;
        entity->pos.y += 18.0f;
    }
}

◆ entity_block_hit_animate_scale()

void entity_block_hit_animate_scale ( Entity * entity )

Definition at line 90 of file Block.c.

                                                    {
    s32 type = get_entity_type(entity->listIndex);
    if (type == ENTITY_TYPE_HAMMER1_BLOCK_TINY || type == ENTITY_TYPE_HAMMER2_BLOCK_TINY || type == ENTITY_TYPE_HAMMER3_BLOCK_TINY) {
        entity->scale.x -= 0.09;
        entity->scale.z -= 0.09;
        entity->scale.y += 0.045;
        entity->pos.y -= 3.0f;
    } else {
        entity->scale.x -= 0.18;
        entity->scale.z -= 0.18;
        entity->scale.y += 0.09;
        entity->pos.y -= 3.0f;
    }
    entity_base_block_idle(entity);
}

◆ entity_block_handle_collision()

s32 entity_block_handle_collision ( Entity * entity )

Definition at line 334 of file Block.c.

                                                  {
    s32 breakBlock;
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    if (entity->alpha == 0 && (entity->collisionFlags & ENTITY_COLLISION_PLAYER_TOUCH_FLOOR)) {
        return FALSE;
    }
 
    if (entity->collisionFlags & ENTITY_COLLISION_PLAYER_TOUCH_CEILING) {
        s32 type = get_entity_type(entity->listIndex);
        switch (type) {
            case ENTITY_TYPE_PUSH_BLOCK:
            case ENTITY_TYPE_HAMMER1_BLOCK:
            case ENTITY_TYPE_HAMMER2_BLOCK:
            case ENTITY_TYPE_HAMMER3_BLOCK:
            case ENTITY_TYPE_HAMMER1_BLOCK_TINY:
            case ENTITY_TYPE_HAMMER2_BLOCK_TINY:
            case ENTITY_TYPE_HAMMER3_BLOCK_TINY:
                return FALSE;
        }
 
        if (playerStatus->flags & PS_FLAG_JUMPING) {
            exec_entity_commandlist(entity);
        }
        return TRUE;
    }
 
    if (entity->collisionFlags & ENTITY_COLLISION_PARTNER) {
        // partner collision means either kooper shell toss or bombette explosion
        if (gPlayerData.curPartner == PARTNER_BOMBETTE) {
            switch (get_entity_type(entity->listIndex)) {
                case ENTITY_TYPE_HAMMER1_BLOCK:
                case ENTITY_TYPE_HAMMER1_BLOCK_TINY:
                    set_entity_commandlist(entity, Entity_BreakingBlock_Script);
                    sfx_play_sound_at_position(SOUND_SMASH_HAMER_BLOCK_1, SOUND_SPACE_DEFAULT, entity->pos.x, entity->pos.y, entity->pos.z);
                    return TRUE;
            }
        }
        exec_entity_commandlist(entity);
        return TRUE;
    }
 
    breakBlock = FALSE;
    if (entity->collisionFlags & ENTITY_COLLISION_PLAYER_TOUCH_FLOOR) {
        if (playerStatus->actionState == ACTION_STATE_SPIN_JUMP || playerStatus->actionState == ACTION_STATE_TORNADO_JUMP) {
            return FALSE;
        }
 
        if (playerStatus->actionState == ACTION_STATE_SPIN_POUND || playerStatus->actionState == ACTION_STATE_TORNADO_POUND) {
            breakBlock = TRUE;
        } else {
            return TRUE;
        }
    } else {
        if (!(entity->collisionFlags & ENTITY_COLLISION_PLAYER_HAMMER)) {
            return TRUE;
        }
        if (!(playerStatus->flags & PS_FLAG_HAMMER_CHECK)) {
            return TRUE;
        }
    }
 
    switch (get_entity_type(entity->listIndex)) {
        case ENTITY_TYPE_BRICK_BLOCK:
        case ENTITY_TYPE_MULTI_COIN_BRICK:
        case ENTITY_TYPE_YELLOW_BLOCK:
        case ENTITY_TYPE_SINGLE_TRIGGER_BLOCK:
        case ENTITY_TYPE_HIDDEN_YELLOW_BLOCK:
        case ENTITY_TYPE_HIDDEN_RED_BLOCK:
        case ENTITY_TYPE_RED_BLOCK:
            exec_entity_commandlist(entity);
            break;
        case ENTITY_TYPE_HAMMER1_BLOCK:
        case ENTITY_TYPE_HAMMER1_BLOCK_TINY:
            if (breakBlock) {
                if (gPlayerData.bootsLevel < 1) {
                    breakBlock = FALSE;
                }
            } else {
                if (gPlayerData.hammerLevel > -1) {
                    breakBlock = TRUE;
                }
            }
            if (!breakBlock) {
                return TRUE;
            }
            set_entity_commandlist(entity, Entity_BreakingBlock_Script);
            sfx_play_sound_at_position(SOUND_SMASH_HAMER_BLOCK_1, SOUND_SPACE_DEFAULT, entity->pos.x, entity->pos.y, entity->pos.z);
            break;
        case ENTITY_TYPE_HAMMER2_BLOCK:
        case ENTITY_TYPE_HAMMER2_BLOCK_TINY:
            if (breakBlock) {
                if (gPlayerData.bootsLevel < 2) {
                    breakBlock = FALSE;
                }
            } else if (gPlayerData.hammerLevel > 0) {
                breakBlock = TRUE;
            }
            if (!breakBlock) {
                return TRUE;
            }
            set_entity_commandlist(entity, Entity_BreakingBlock_Script);
            sfx_play_sound_at_position(SOUND_SMASH_HAMER_BLOCK_2, SOUND_SPACE_DEFAULT, entity->pos.x, entity->pos.y, entity->pos.z);
            break;
        case ENTITY_TYPE_HAMMER3_BLOCK:
        case ENTITY_TYPE_HAMMER3_BLOCK_TINY:
            if (gPlayerData.hammerLevel < 2) {
                return TRUE;
            }
            set_entity_commandlist(entity, Entity_BreakingBlock_Script);
            sfx_play_sound_at_position(SOUND_SMASH_HAMER_BLOCK_3, SOUND_SPACE_DEFAULT, entity->pos.x, entity->pos.y, entity->pos.z);
            break;
        case ENTITY_TYPE_MULTI_TRIGGER_BLOCK:
        case ENTITY_TYPE_HEALING_BLOCK:
        case ENTITY_TYPE_1C:
        case ENTITY_TYPE_1D:
        case ENTITY_TYPE_1E:
        case ENTITY_TYPE_HEALING_BLOCK_FRAME:
            entity_start_script(entity);
            exec_entity_commandlist(entity);
            break;
        case ENTITY_TYPE_PUSH_BLOCK:
            entity_start_script(entity);
            break;
        case ENTITY_TYPE_INACTIVE_BLOCK:
            break;
    }
 
    return TRUE;
}

◆ entity_BlueSwitch_init()

void entity_BlueSwitch_init ( Entity * entity )

Definition at line 457 of file Switch.c.

                                            {
    SwitchData* data = entity->dataBuf.swtch;
 
    entity_base_switch_init(entity);
    if (CreateEntityVarArgBuffer[0] == REFLECTED_SWITCH_LINKED) {
        SwitchToLink = entity;
        return;
    }
 
    if (CreateEntityVarArgBuffer[0] == REFLECTED_SWITCH_HIDDEN) {
        if (SwitchToLink != NULL) {
            data->linkedSwitch = SwitchToLink;
            entity->flags |= ENTITY_FLAG_HIDDEN;
            return;
        }
    } else {
        SwitchToLink = NULL;
    }
}

◆ entity_HugeBlueSwitch_init()

void entity_HugeBlueSwitch_init ( Entity * entity )

Definition at line 477 of file Switch.c.

                                                {
    SwitchData* data;
 
    entity_base_switch_init(entity);
    data = entity->dataBuf.swtch;
    entity->scale.x = 3.0f;
    entity->scale.y = 3.0f;
    entity->scale.z = 3.0f;
    data->baseScale.x = 3.0f;
    data->baseScale.y = 3.0f;
    data->baseScale.z = 3.0f;
}

◆ dispatch_damage_event_actor_0()

s32 dispatch_damage_event_actor_0	(	Actor *	actor,
		s32	damageAmount,
		s32	event )

Definition at line 889 of file 1A5830.c.

                                                                             {
    return dispatch_damage_event_actor(actor, damageAmount, event, FALSE);
}

Referenced by btl_state_update_9().

◆ msg_get_printer_for_msg()

MessagePrintState * msg_get_printer_for_msg	(	s32	msgID,
		s32 *	a1 )

Definition at line 1424 of file msg.c.

                                                                                  {
    return _msg_get_printer_for_msg(msgID, donePrintingWriteback, 0);
}

Referenced by _show_message(), entity_HeartBlock_show_tutorial_message(), entity_SaveBlock_show_choice_message(), entity_SaveBlock_show_tutorial_message(), popup_menu_update(), and update_item_entity_pickup().

◆ msg_printer_load_msg()

s32 msg_printer_load_msg	(	s32	msgID,
		MessagePrintState *	printer )

Definition at line 1474 of file msg.c.

                                                                {
    s8* buffer;
 
    if (msgID >= 0) {
        buffer = load_message_to_buffer(msgID);
    } else {
        buffer = (s8*) msgID;
    }
 
    printer->srcBuffer = buffer;
    printer->srcBufferPos = 0;
    printer->stateFlags &= ~MSG_STATE_FLAG_40;
    return 1;
}

Referenced by _show_message(), and entity_SaveBlock_show_result_message().

◆ msg_printer_set_origin_pos()

void msg_printer_set_origin_pos	(	MessagePrintState *	msgPrintState,
		s32	x,
		s32	y )

Definition at line 1489 of file msg.c.

                                                                                {
    msgPrintState->initOpenPos.x = x;
    msgPrintState->initOpenPos.y = y;
 
    if (msgPrintState->initOpenPos.x < 0) {
        msgPrintState->initOpenPos.x = 0;
    }
    if (msgPrintState->initOpenPos.x > SCREEN_WIDTH) {
        msgPrintState->initOpenPos.x = SCREEN_WIDTH;
    }
    if (msgPrintState->initOpenPos.y < 0) {
        msgPrintState->initOpenPos.y = 0;
    }
    if (msgPrintState->initOpenPos.y > 220) {
        msgPrintState->initOpenPos.y = 220;
    }
}

Referenced by _show_message(), popup_menu_update(), and update_item_entity_pickup().

◆ get_screen_coords()

void get_screen_coords	(	s32	camID,
		f32	x,
		f32	y,
		f32	z,
		s32 *	screenX,
		s32 *	screenY,
		s32 *	screenZ )

Definition at line 410 of file cam_main.c.

                                                                                                 {
    Camera* camera = &gCameras[camID];
    f32 tW;
    f32 tZ;
    f32 tY;
    f32 tX;
 
    transform_point(camera->mtxPerspective, x, y, z, 1.0f, &tX, &tY, &tZ, &tW);
 
    *screenZ = tZ + 5000.0f;
    if (*screenZ < 0) {
        *screenZ = 0;
    } else if (*screenZ > 10000) {
        *screenZ = 10000;
    }
 
    if (tW < 0.01 && tW > -0.01) {
        *screenX = 0;
        *screenY = 0;
        *screenZ = 0;
    } else {
        *screenX = camera->viewportStartX + (s32) ((1.0f + tX / tW) * camera->viewportW * 0.5f);
        *screenY = camera->viewportStartY + (s32) ((1.0f - tY / tW) * camera->viewportH * 0.5f);
    }
}

Referenced by _show_message(), btl_draw_enemy_health_bars(), btl_state_draw_select_target(), draw_all_status_icons(), draw_encounters_pre_battle(), render_player_model(), sfx_compute_spatialized_sound_params_full(), sfx_compute_spatialized_sound_params_ignore_depth(), sfx_compute_spatialized_sound_params_with_depth(), update_cameras(), and update_encounters_neutral().

◆ parent_collider_to_model()

void parent_collider_to_model	(	s16	colliderID,
		s16	modelIndex )

Definition at line 320 of file collision.c.

                                                              {
    Collider* collider;
    ColliderTriangle* triangle;
    s32 i;
    Vec3f** vertexBuffer;
    Vec3f** vertexPtr;
    s32 vertexBufferSize;
    Vec3f* vertexTable;
    Vec3f* vertex;
 
    collider = &gCollisionData.colliderList[colliderID];
    collider->parentModelIndex = modelIndex;
    collider->flags |= COLLIDER_FLAG_HAS_MODEL_PARENT;
 
    vertexBuffer = collision_heap_malloc(collider->numTriangles * sizeof(Vec3f));
    vertexBufferSize = 0;
    vertexPtr = vertexBuffer;
 
    for (i = 0, triangle = collider->triangleTable; i < collider->numTriangles; i++, triangle++) {
        _add_hit_vert_to_buffer(vertexBuffer, triangle->v1, &vertexBufferSize);
        _add_hit_vert_to_buffer(vertexBuffer, triangle->v2, &vertexBufferSize);
        _add_hit_vert_to_buffer(vertexBuffer, triangle->v3, &vertexBufferSize);
    }
 
    collider->numVertices = vertexBufferSize;
    collider->vertexTable = collision_heap_malloc(vertexBufferSize * 2 * sizeof(Vec3f));
    for (i = 0, vertexTable = collider->vertexTable; i < vertexBufferSize; vertexPtr++, vertexTable += 2, i++) {
        vertex = *vertexPtr;
        vertexTable[0].x = vertexTable[1].x = vertex->x;
        vertexTable[0].y = vertexTable[1].y = vertex->y;
        vertexTable[0].z = vertexTable[1].z = vertex->z;
    }
 
    vertexTable = collider->vertexTable;
    for (i = 0, triangle = collider->triangleTable; i < collider->numTriangles; triangle++, i++) {
        triangle->v1 = &vertexTable[_get_hit_vert_index_from_buffer(vertexBuffer, triangle->v1, &vertexBufferSize) * 2];
        triangle->v2 = &vertexTable[_get_hit_vert_index_from_buffer(vertexBuffer, triangle->v2, &vertexBufferSize) * 2];
        triangle->v3 = &vertexTable[_get_hit_vert_index_from_buffer(vertexBuffer, triangle->v3, &vertexBufferSize) * 2];
    }
 
    collision_heap_free(vertexBuffer);
}

Referenced by restore_map_collision_data().

◆ clone_model()

void clone_model	(	u16	srcModelID,
		u16	newModelID )

Definition at line 3620 of file model.c.

                                                 {
    Model* srcModel = get_model_from_list_index(get_model_list_index_from_tree_index(srcModelID));
    Model* newModel;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentModels); i++) {
        if ((*gCurrentModels)[i] == NULL) {
            break;
        }
    }
 
    (*gCurrentModels)[i] = newModel = heap_malloc(sizeof(*newModel));
    *newModel = *srcModel;
    newModel->modelID = newModelID;
}

◆ get_model_from_list_index()

struct Model * get_model_from_list_index ( s32 listIndex )

Definition at line 3314 of file model.c.

                                                {
    return (*gCurrentModels)[listIndex];
}

Referenced by animator_node_update_model_transform(), clone_model(), disable_transform_group(), enable_transform_group(), get_model_center_and_size(), get_model_list_index_from_tree_index(), hide_foreground_models(), hide_foreground_models_unchecked(), is_model_center_visible(), mdl_draw_hidden_panel_surface(), mdl_make_local_vertex_copy(), mdl_project_tex_coords(), render_transform_group_node(), show_foreground_models(), show_foreground_models_unchecked(), and update_collider_transform().

◆ create_model_animator()

s32 create_model_animator ( s16 * animPos )

Definition at line 318 of file animator.c.

                                        {
    ModelAnimator* animator;
    s32 i, j;
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentAnimMeshListPtr); i++) {
        if ((*gCurrentAnimMeshListPtr)[i] == NULL) {
            break;
        }
    }
 
    ASSERT(i < ARRAY_COUNT(*gCurrentAnimMeshListPtr));
 
    (*gCurrentAnimMeshListPtr)[i] = animator = heap_malloc(sizeof(*animator));
    gAnimCount++;
 
    ASSERT(animator != NULL);
 
    animator->flags = MODEL_ANIMATOR_FLAG_UPDATE_PENDING | MODEL_ANIMATOR_FLAG_ENABLED | MODEL_ANIMATOR_FLAG_CAM_2 | MODEL_ANIMATOR_FLAG_CAM_1 | MODEL_ANIMATOR_FLAG_CAM_0;
    animator->renderMode = RENDER_MODE_ALPHATEST;
    animator->nextUpdateTime = 1.0f;
    animator->timeScale = 1.0f;
    animator->animReadPos = animPos;
 
    if (animPos == NULL) {
        animator->animReadPos = gAnimScriptDefault;
    }
 
    animator->savedReadPos = animPos;
    animator->animationBuffer = NULL;
    animator->baseAddr = NULL;
    animator->fpRenderCallback = NULL;
    animator->rootNode = NULL;
    animator->nextUniqueID = 0;
 
    for (j = 0; j < ARRAY_COUNT(animator->nodeCache); j++) {
        animator->nodeCache[j] = NULL;
    }
 
    for (j = 0; j < ARRAY_COUNT(animator->staticNodeIDs); j++) {
        animator->staticNodeIDs[j] = j + 1;
    }
 
    if (gGameStatusPtr->context != CONTEXT_WORLD) {
        i |= BATTLE_ID_BIT;
    }
    return i;
}

Referenced by create_shadow_from_data(), and load_split_entity_data().

◆ get_model_list_index_from_tree_index()

s32 get_model_list_index_from_tree_index ( s32 treeIndex )

Definition at line 3396 of file model.c.

                                                        {
    s32 i;
 
    if (treeIndex < MAX_MODELS) {
        u8 modelIndex = (*gCurrentModelTreeNodeInfo)[treeIndex].modelIndex;
 
        if (modelIndex != (u8)-1) {
            return modelIndex;
        }
    }
 
    for (i = 0; i < MAX_MODELS; i++) {
        Model* model = get_model_from_list_index(i);
 
        if (model != NULL && model->modelID == treeIndex) {
            return i;
        }
    }
    return 0;
}

Referenced by animator_node_update_model_transform(), clone_model(), get_model_center_and_size(), hide_foreground_models(), hide_foreground_models_unchecked(), is_model_center_visible(), mdl_draw_hidden_panel_surface(), mdl_make_local_vertex_copy(), mdl_make_transform_group(), mdl_project_tex_coords(), show_foreground_models(), and show_foreground_models_unchecked().

◆ get_transform_group_index()

s32 get_transform_group_index ( s32 modelID )

Definition at line 3417 of file model.c.

                                           {
    ModelTransformGroup* group;
    s32 i;
 
    for (i = 0; i < MAX_MODEL_TRANSFORM_GROUPS; i++) {
        group = get_transform_group(i);
 
        if (group != NULL && group->groupModelID == modelID) {
            return i;
        }
    }
 
    return -1;
}

Referenced by disable_transform_group(), and enable_transform_group().

◆ get_model_center_and_size()

void get_model_center_and_size	(	u16	modelID,
		f32 *	centerX,
		f32 *	centerY,
		f32 *	centerZ,
		f32 *	sizeX,
		f32 *	sizeY,
		f32 *	sizeZ )

Definition at line 3432 of file model.c.

                                                                                                                          {
    Model* model = get_model_from_list_index(get_model_list_index_from_tree_index(modelID));
    ModelNode* node = model->modelNode;
    ModelBoundingBox* bb;
 
    *centerX = model->center.x;
    *centerY = model->center.y;
    *centerZ = model->center.z;
 
    bb = (ModelBoundingBox*)get_model_property(node, MODEL_PROP_KEY_BOUNDING_BOX);
 
    if (bb != NULL) {
        *sizeX = bb->halfSizeX;
        *sizeY = bb->halfSizeY;
        *sizeZ = bb->halfSizeZ;
    } else {
        *sizeX = *sizeY = *sizeZ = 0.0f;
    }
}

◆ collision_main_above()

HitID collision_main_above ( void )

Definition at line 68 of file 7BB60.c.

                                 {
    PlayerStatus* playerStatus = &gPlayerStatus;
    CollisionStatus* collisionStatus = &gCollisionStatus;
    HitID hitResult;
    f32 x, y, z;
    f32 halfHeight;
    f32 moveAngle;
    f32 moveMagnitude;
    f32 outDepth;
 
    outDepth = halfHeight = playerStatus->colliderHeight * 0.5f;
    x = playerStatus->pos.x;
    y = playerStatus->pos.y + halfHeight;
    z = playerStatus->pos.z;
 
    player_input_to_move_vector(&moveAngle, &moveMagnitude);
 
    if (moveMagnitude != 0.0f) {
        moveAngle = playerStatus->targetYaw;
    } else {
        moveAngle = playerStatus->spriteFacingAngle - 90.0f + gCameras[gCurrentCameraID].curYaw;
    }
 
    hitResult = player_raycast_up_corners(playerStatus, &x, &y, &z, &outDepth, moveAngle);
    collisionStatus->curCeiling = hitResult;
 
    if (hitResult > NO_COLLIDER) {
        if (playerStatus->actionState != ACTION_STATE_FALLING
            && playerStatus->actionState != ACTION_STATE_STEP_DOWN
            && collisionStatus->curFloor <= NO_COLLIDER
        ) {
            if (outDepth <= fabsf(halfHeight + playerStatus->gravityIntegrator[0])) {
                if ((hitResult & COLLISION_WITH_ENTITY_BIT) && get_entity_type(hitResult) == ENTITY_TYPE_BRICK_BLOCK) {
                    return hitResult;
                }
 
                playerStatus->pos.y = y - ((playerStatus->colliderHeight / 5.0f) * 3.0f);
                if (playerStatus->actionState != ACTION_STATE_TORNADO_JUMP
                    && playerStatus->actionState != ACTION_STATE_SPIN_JUMP
                ) {
                    playerStatus->gravityIntegrator[0] = 0.0f;
                    playerStatus->gravityIntegrator[1] = 0.0f;
                    playerStatus->gravityIntegrator[2] = 0.0f;
                    playerStatus->gravityIntegrator[3] = 0.0f;
                }
            }
        }
    }
 
    return hitResult;
}

Referenced by phys_update_standard().

◆ collision_lava_reset_check_additional_overlaps()

void collision_lava_reset_check_additional_overlaps ( void )

Definition at line 990 of file 7BB60.c.

                                                          {
    PlayerStatus* playerStatus = &gPlayerStatus;
    f32 x, y, z;
    f32 yaw;
 
    if (playerStatus->animFlags & PA_FLAG_USING_PEACH_PHYSICS) {
        collision_lateral_peach();
        return;
    }
 
    yaw = clamp_angle(playerStatus->targetYaw - 30.0);
    y = playerStatus->pos.y + (playerStatus->colliderHeight * 0.75f);
    x = playerStatus->pos.x;
    z = playerStatus->pos.z;
    player_test_lateral_overlap(PLAYER_COLLISION_0, &gPlayerStatus, &x, &y, &z, 0.0f, yaw);
    playerStatus->pos.x = x;
    playerStatus->pos.z = z;
 
    yaw = clamp_angle(playerStatus->targetYaw + 30.0);
    y = playerStatus->pos.y + (playerStatus->colliderHeight * 0.75f);
    x = playerStatus->pos.x;
    z = playerStatus->pos.z;
    player_test_lateral_overlap(PLAYER_COLLISION_0, &gPlayerStatus, &x, &y, &z, 0.0f, yaw);
    playerStatus->pos.x = x;
    playerStatus->pos.z = z;
 
    yaw = clamp_angle(playerStatus->targetYaw - 30.0);
    x = playerStatus->pos.x;
    y = playerStatus->pos.y;
    z = playerStatus->pos.z;
    player_test_lateral_overlap(PLAYER_COLLISION_0, &gPlayerStatus, &x, &y, &z, 0.0f, yaw);
    playerStatus->pos.x = x;
    playerStatus->pos.z = z;
 
    yaw = clamp_angle(playerStatus->targetYaw + 30.0);
    x = playerStatus->pos.x;
    y = playerStatus->pos.y;
    z = playerStatus->pos.z;
    player_test_lateral_overlap(PLAYER_COLLISION_0, &gPlayerStatus, &x, &y, &z, 0.0f, yaw);
    playerStatus->pos.x = x;
    playerStatus->pos.z = z;
 
    yaw = clamp_angle(playerStatus->targetYaw + 90.0);
    x = playerStatus->pos.x;
    y = playerStatus->pos.y;
    z = playerStatus->pos.z;
    player_test_lateral_overlap(PLAYER_COLLISION_0, &gPlayerStatus, &x, &y, &z, 0.0f, yaw);
    playerStatus->pos.x = x;
    playerStatus->pos.z = z;
    yaw = clamp_angle(playerStatus->targetYaw - 90.0);
 
    x = playerStatus->pos.x;
    y = playerStatus->pos.y;
    z = playerStatus->pos.z;
    player_test_lateral_overlap(PLAYER_COLLISION_0, &gPlayerStatus, &x, &y, &z, 0.0f, yaw);
    playerStatus->pos.x = x;
    playerStatus->pos.z = z;
 
    yaw = clamp_angle(playerStatus->targetYaw + 180.0);
    x = playerStatus->pos.x;
    y = playerStatus->pos.y;
    z = playerStatus->pos.z;
    player_test_lateral_overlap(PLAYER_COLLISION_0, &gPlayerStatus, &x, &y, &z, 0.0f, yaw);
    playerStatus->pos.x = x;
    playerStatus->pos.z = z;
}

Referenced by action_update_use_spinning_flower(), and phys_update_lava_reset().

◆ player_test_lateral_overlap()

s32 player_test_lateral_overlap	(	s32	mode,
		PlayerStatus *	playerStatus,
		f32 *	x,
		f32 *	y,
		f32 *	z,
		f32	length,
		f32	yaw )

Definition at line 370 of file 77480.c.

                                                                                                                     {
    f32 sinTheta;
    f32 cosTheta;
    f32 hitX;
    f32 hitY;
    f32 hitZ;
    f32 hitDepth;
    f32 hitNx;
    f32 hitNy;
    f32 hitNz;
    f32 slipDx;
    f32 slipDz;
    f32 depthDiff;
    f32 radius;
    f32 originalDepth;
    s32 hitID;
    f32 height;
    f32 targetDx;
    f32 targetDz;
    f32 dx;
    f32 dz;
    s32 ret;
 
    radius = playerStatus->colliderDiameter * 0.5f;
    ret = NO_COLLIDER;
 
    if (!(playerStatus->flags & (PS_FLAG_FALLING | PS_FLAG_JUMPING))) {
        height = playerStatus->colliderHeight * 0.286f;
    } else {
        height = 1.0f;
    }
 
    sin_cos_rad(DEG_TO_RAD(yaw), &sinTheta, &cosTheta);
    cosTheta = -cosTheta;
    hitDepth = length + radius;
    hitID = player_raycast_general(mode, *x, *y + height, *z, sinTheta, 0, cosTheta, &hitX, &hitY, &hitZ, &hitDepth, &hitNx, &hitNy, &hitNz);
 
    if (mode == PLAYER_COLLISION_HAMMER) {
        targetDx = 0.0f;
        targetDz = 0.0f;
    } else {
        targetDx = length * sinTheta;
        targetDz = length * cosTheta;
    }
 
    if (hitID > NO_COLLIDER) {
        originalDepth = length + radius;
        if (hitDepth <= originalDepth) {
            depthDiff = hitDepth - originalDepth;
            dx = depthDiff * sinTheta;
            dz = depthDiff * cosTheta;
 
            player_get_slip_vector(&slipDx, &slipDz, targetDx, targetDz, hitNx, hitNz);
            *x += dx + slipDx;
            *z += dz + slipDz;
            ret = hitID;
        }
    }
 
    *x += targetDx;
    *z += targetDz;
    return ret;
}

Referenced by action_hammer_end_swing(), action_hammer_test_swing_collision(), check_for_treadmill_overlaps(), collision_check_player_intersecting_world(), collision_check_player_overlaps(), collision_lava_reset_check_additional_overlaps(), collision_main_lateral(), func_800E4404(), and peach_disguise_check_overlaps().

◆ peach_make_disguise_npc()

Npc * peach_make_disguise_npc ( s32 peachDisguise )

Definition at line 573 of file 7E9D0.c.

                                                {
    PlayerStatus* playerStatus = &gPlayerStatus;
    NpcBlueprint bp;
    NpcBlueprint* bpPtr = &bp;
    Npc* npc;
    f32 yaw;
 
    if (peachDisguise == PEACH_DISGUISE_NONE) {
        return NULL;
    }
 
    playerStatus->colliderHeight = 37;
    playerStatus->colliderDiameter = 38;
    playerStatus->peachDisguise = peachDisguise;
    gGameStatusPtr->peachDisguise = peachDisguise;
 
    bpPtr->flags = NPC_FLAG_FLYING | NPC_FLAG_IGNORE_WORLD_COLLISION | NPC_FLAG_IGNORE_PLAYER_COLLISION | NPC_FLAG_IGNORE_CAMERA_FOR_YAW;
    bpPtr->initialAnim = BasicPeachDisguiseAnims[playerStatus->peachDisguise].idle;
    bpPtr->onUpdate = NULL;
    bpPtr->onRender = NULL;
 
    PeachDisguiseNpcIndex = create_standard_npc(bpPtr, PeachDisguiseExtraAnims[playerStatus->peachDisguise]);
    npc = get_npc_by_index(PeachDisguiseNpcIndex);
 
    disable_npc_shadow(npc);
 
    if (!(playerStatus->spriteFacingAngle >= 90.0f) || !(playerStatus->spriteFacingAngle < 270.0f)) {
        yaw = 180.0f;
    } else {
        yaw = 0.0f;
    }
 
    set_npc_yaw(npc, yaw);
 
    npc->pos.x = playerStatus->pos.x;
    npc->pos.y = playerStatus->pos.y;
    npc->pos.z = playerStatus->pos.z;
 
    return npc;
}

Referenced by action_update_parasol(), and peach_check_for_parasol_input().

◆ peach_set_disguise_anim()

void peach_set_disguise_anim ( AnimID anim )

Definition at line 506 of file 7E9D0.c.

                                          {
    s32 listIndex = PeachDisguiseNpcIndex;
 
    if (listIndex >= 0) {
        get_npc_by_index(listIndex)->curAnim = anim;
    }
}

Referenced by action_update_idle_peach(), action_update_step_up_set_peach_anim(), action_update_talk(), action_update_walk_set_peach_anim(), and get_overriding_player_anim().

◆ draw_box()

s32 draw_box	(	s32	flags,
		WindowStyle	windowStyle,
		s32	posX,
		s32	posY,
		s32	posZ,
		s32	width,
		s32	height,
		u8	opacity,
		u8	darkening,
		f32	scaleX,
		f32	scaleY,
		f32	rotX,
		f32	rotY,
		f32	rotZ,
		void(*)(s32, s32, s32, s32, s32, s32, s32)	fpDrawContents,
		void *	drawContentsArg0,
		Matrix4f	rotScaleMtx,
		s32	translateX,
		s32	translateY,
		Matrix4f	outMtx )

Definition at line 337 of file draw_box.c.

{
    Matrix4f mtx1, mtx2, mtx3;
    u8 primR, primG, primB, primA, envR, envG, envB, envA;
    DefaultWindowStyle* defaultStyle = NULL;
    WindowStyleCustom* customStyle = NULL;
    WindowCorners* corners;
    WindowBackground* background;
    u32 bgWidth, bgHeight;
    u32 cornerWidth, cornerHeight;
    s32 masks, maskt;
    Vtx* quads;
    s32 idx;
    s32 i, j;
    s32 tmem = 0x100;
    u32 bgScrollOffsetX, bgScrollOffsetY;
 
    s32 foo;
    s32 alpha = foo * opacity / 255;
 
    if (windowStyle.defaultStyleID <= WINDOW_STYLE_MAX && windowStyle.defaultStyleID >= 0) {
        defaultStyle = &gBoxDefaultStyles[windowStyle.defaultStyleID];
 
        primR = defaultStyle->color1.r;
        primG = defaultStyle->color1.g;
        primB = defaultStyle->color1.b;
        primA = defaultStyle->color1.a * opacity / 255;
        envR = defaultStyle->color2.r;
        envG = defaultStyle->color2.g;
        envB = defaultStyle->color2.b;
        envA = defaultStyle->color2.a;
 
        background = &gBoxBackground[defaultStyle->bgIndex];
        corners = &gBoxCorners[defaultStyle->cornersIndex];
    } else {
        primR = windowStyle.customStyle->color1.r;
        primG = windowStyle.customStyle->color1.g;
        primB = windowStyle.customStyle->color1.b;
        primA = windowStyle.customStyle->color1.a * opacity / 255;
        envR = windowStyle.customStyle->color2.r;
        envG = windowStyle.customStyle->color2.g;
        envB = windowStyle.customStyle->color2.b;
        envA = windowStyle.customStyle->color2.a;
 
        customStyle = windowStyle.customStyle;
        background = &windowStyle.customStyle->background;
        corners = &windowStyle.customStyle->corners;
    }
    {
        u8* bgImage;
        u8* cornersImage;
        s32 bgFmt;
        s32 bgMasks;
        s32 bgMaskt;
        Vec2bu* cornersSizes;
        u32 cornersFmt;
        u32 cornersBitDepth;
        Mtx* sp154;
 
        bgFmt = background->fmt;
        cornersImage = corners->imgData;
 
        bgWidth = background->width;
        bgImage = background->imgData;
        bgHeight = background->height;
 
        bgMasks = INTEGER_LOG2(bgWidth);
        bgMaskt = INTEGER_LOG2(bgHeight);
 
        quads = NULL;
        sp154 = NULL;
        cornersSizes = (Vec2bu*)&corners->size1;
        cornersFmt = corners->fmt;
        cornersBitDepth = corners->bitDepth;
 
        if (width <= 0 || height <= 0 || opacity == 0 || posX <= -768 || posY <= -768) {
            return TRUE;
        }
 
        if (posX >= SCREEN_WIDTH || posY >= SCREEN_HEIGHT) {
            return TRUE;
        }
 
        if (posX + width >= 768 || posY + height >= 768 || posX + width <= 0 || posY + height <= 0) {
            return TRUE;
        }
 
        if (flags & DRAW_FLAG_ROTSCALE) {
            quads = gBoxQuadBuffer[gBoxQuadIndex++];
            if (gBoxQuadIndex > BOX_QUAD_BUFFER_NUM - 1) {
                gBoxQuadIndex = 0;
            }
        }
 
        gDPPipeSync(gMainGfxPos++);
        gDPSetCycleType(gMainGfxPos++, G_CYC_2CYCLE);
        gDPSetBlendColor(gMainGfxPos++, 0, 0, 0, 0);
        gDPSetFogColor(gMainGfxPos++, 0, 0, 0, darkening);
        gDPSetRenderMode(gMainGfxPos++, PM_RM_SHROUD, G_RM_XLU_SURF2);
        if (!(flags & DRAW_FLAG_NO_CLIP)) {
            gDPSetScissor(gMainGfxPos++, G_SC_NON_INTERLACE, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
        }
 
        if (defaultStyle != NULL) {
            Gfx* gfxPos = gMainGfxPos;
            *gfxPos = gBoxCombineModes[defaultStyle->combineModeIndex + (primA != 255 ? 2 : 0)];
        } else {
            Gfx* gfxPos = gMainGfxPos;
            if (primA != 255) {
                *gfxPos = customStyle->transparentCombineMode;
            } else {
                *gfxPos = customStyle->opaqueCombineMode;
            }
        }
 
        gMainGfxPos++;
        gDPSetTextureFilter(gMainGfxPos++, G_TF_POINT);
 
        if (quads != NULL) {
            gSPViewport(gMainGfxPos++, &gBoxViewport);
            guFrustumF(mtx1, -80.0f, 80.0f, 60.0f, -60.0f, 160.0f, 480.0f, 1.0f);
            guMtxF2L(mtx1, &gDisplayContext->matrixStack[gMatrixListPos]);
            sp154 = &gDisplayContext->matrixStack[gMatrixListPos];
            gSPMatrix(gMainGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++], G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
            guPositionF(mtx1, rotX, rotY, rotZ, 1.0f, posX + width / 2, posY + height / 2, posZ);
            if (scaleX != 1.0f || scaleY != 1.0f) {
                guScaleF(mtx2, scaleX, scaleY, 1.0f);
                guMtxCatF(mtx2, mtx1, mtx1);
            }
            if (rotScaleMtx != 0) {
                guTranslateF(mtx2, -translateX / 2, -translateY / 2, 0.0f);
                guMtxCatF(mtx1, mtx2, mtx2);
                guMtxCatF(mtx2, rotScaleMtx, mtx1);
            }
            if (outMtx) {
                for (i = 0; i < 4; i++) {
                    for (j = 0; j < 4; j++) {
                        outMtx[i][j] = mtx1[i][j];
                    }
                }
            }
            guTranslateF(mtx2, -160.0f, -120.0f, -320.0f);
            guMtxCatF(mtx1, mtx2, mtx1);
            gSPClearGeometryMode(gMainGfxPos++, G_CULL_BOTH | G_LIGHTING);
            if (flags & DRAW_FLAG_CULL_BACK) {
                gSPSetGeometryMode(gMainGfxPos++, G_CULL_BACK);
            }
            guMtxF2L(mtx1, &gDisplayContext->matrixStack[gMatrixListPos]);
            gSPMatrix(gMainGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++], G_MTX_PUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
            gDPSetTexturePersp(gMainGfxPos++, G_TP_PERSP);
            gSPPerspNormalize(gMainGfxPos++, 20);
        } else {
            gDPSetTexturePersp(gMainGfxPos++, G_TP_NONE);
        }
 
        gSPTexture(gMainGfxPos++, 0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON);
        gDPSetTextureLUT(gMainGfxPos++, G_TT_NONE);
        gDPSetTextureDetail(gMainGfxPos++, G_TD_CLAMP);
        gDPSetTextureLOD(gMainGfxPos++, G_TL_TILE);
        gDPSetPrimColor(gMainGfxPos++, 0, 0, primR, primG, primB, primA);
        gDPSetEnvColor(gMainGfxPos++, envR, envG, envB, envA);
        if (bgImage != NULL) {
            switch (background->bitDepth) {
                case G_IM_SIZ_4b:
                    gDPLoadTextureTile_4b(gMainGfxPos++, bgImage, bgFmt, bgWidth, bgHeight, 0, 0, bgWidth - 1, bgHeight - 1, 0, G_TX_WRAP, G_TX_WRAP, bgMasks, bgMaskt, G_TX_NOLOD, G_TX_NOLOD);
                    break;
                case G_IM_SIZ_8b:
                    gDPLoadTextureTile(gMainGfxPos++, bgImage, bgFmt, G_IM_SIZ_8b, bgWidth, bgHeight, 0, 0, bgWidth - 1, bgHeight - 1, 0, G_TX_WRAP, G_TX_WRAP, bgMasks, bgMaskt, G_TX_NOLOD, G_TX_NOLOD);
                    break;
                case G_IM_SIZ_16b:
                    gDPLoadTextureTile(gMainGfxPos++, bgImage, bgFmt, G_IM_SIZ_16b, bgWidth, bgHeight, 0, 0, bgWidth - 1, bgHeight - 1, 0, G_TX_WRAP, G_TX_WRAP, bgMasks, bgMaskt, G_TX_NOLOD, G_TX_NOLOD);
                    break;
                case G_IM_SIZ_32b:
                    gDPLoadTextureTile(gMainGfxPos++, bgImage, bgFmt, G_IM_SIZ_32b, bgWidth, bgHeight, 0, 0, bgWidth - 1, bgHeight - 1, 0, G_TX_WRAP, G_TX_WRAP, bgMasks, bgMaskt, G_TX_NOLOD, G_TX_NOLOD);
                    break;
            }
 
            if (flags & DRAW_FLAG_ANIMATED_BACKGROUND) {
                bgScrollOffsetY = (gGameStatusPtr->frameCounter * 4) & 0x1FF;
                bgScrollOffsetX = 511 - bgScrollOffsetY;
                gDPSetTileSize(gMainGfxPos++, G_TX_RENDERTILE,
                    width / 2 * 4 + bgScrollOffsetX,
                    height / 2 * 4 + bgScrollOffsetY,
                    (width / 2 + bgWidth - 1) * 4 + bgScrollOffsetX,
                    (height / 2 + bgHeight - 1) * 4 + bgScrollOffsetY);
            } else {
                gDPSetTileSize(gMainGfxPos++, G_TX_RENDERTILE, width / 2 * 4, height / 2 * 4,
                               (width / 2 + bgWidth - 1) * 4, (height / 2 + bgHeight - 1)* 4);
            }
        }
 
        if (cornersImage != NULL) {
            for (idx = 0; idx < 4; idx++) {
                cornerWidth = cornersSizes[idx].x;
                cornerHeight = cornersSizes[idx].y;
                masks = INTEGER_LOG2(cornerWidth);
                maskt = INTEGER_LOG2(cornerHeight);
 
                switch (cornersBitDepth) {
                    case G_IM_SIZ_4b:
                        gDPLoadMultiTile_4b(gMainGfxPos++, cornersImage, tmem, 1, cornersFmt, cornerWidth, cornerHeight, 0, 0, cornerWidth - 1, cornerHeight - 1, 0, G_TX_CLAMP, G_TX_CLAMP, masks, maskt, G_TX_NOLOD, G_TX_NOLOD);
                        cornersImage += cornerWidth * cornerHeight / 2;
                        break;
                    case G_IM_SIZ_8b:
                        gDPLoadMultiTile(gMainGfxPos++, cornersImage, tmem, 1, cornersFmt, G_IM_SIZ_8b, cornerWidth, cornerHeight, 0, 0, cornerWidth - 1, cornerHeight - 1, 0, G_TX_CLAMP, G_TX_CLAMP, masks, maskt, G_TX_NOLOD, G_TX_NOLOD);
                        cornersImage += cornerWidth * cornerHeight;
                        break;
                    case G_IM_SIZ_16b:
                        gDPLoadMultiTile(gMainGfxPos++, cornersImage, tmem, 1, cornersFmt, G_IM_SIZ_16b, cornerWidth, cornerHeight, 0, 0, cornerWidth - 1, cornerHeight - 1, 0, G_TX_CLAMP, G_TX_CLAMP, masks, maskt, G_TX_NOLOD, G_TX_NOLOD);
                        cornersImage += cornerWidth * cornerHeight * 2;
                        break;
                    case G_IM_SIZ_32b:
                        gDPLoadMultiTile(gMainGfxPos++, cornersImage, tmem, 1, cornersFmt, G_IM_SIZ_32b, cornerWidth, cornerHeight, 0, 0, cornerWidth - 1, cornerHeight - 1, 0, G_TX_CLAMP, G_TX_CLAMP, masks, maskt, G_TX_NOLOD, G_TX_NOLOD);
                        cornersImage += cornerWidth * cornerHeight * 4;
                        break;
                }
 
                switch(idx) {
                    case 1:
                        gDPSetTileSize(gMainGfxPos++, 1, (width - cornerWidth) * 4, 0, (width - 1) * 4, (cornerHeight - 1) * 4);
                        break;
                    case 2:
                        gDPSetTileSize(gMainGfxPos++, 1, 0, (height - cornerHeight) * 4, (cornerWidth - 1) * 4, (height - 1) * 4);
                        break;
                    case 3:
                        gDPSetTileSize(gMainGfxPos++, 1, (width - cornerWidth) * 4, (height - cornerHeight) * 4, (width - 1) * 4, (height - 1) * 4);
                        break;
                }
 
                if (quads != NULL) {
                    switch(idx) {
                        case 0:
                            quads[0].v.ob[0] = -width / 2;
                            quads[0].v.ob[1] = -height / 2;
                            quads[0].v.ob[2] = 0;
 
                            quads[1].v.ob[0] = 0;
                            quads[1].v.ob[1] = -height / 2;
                            quads[1].v.ob[2] = 0;
 
                            quads[2].v.ob[0] = -width / 2;
                            quads[2].v.ob[1] = 0;
                            quads[2].v.ob[2] = 0;
 
                            quads[3].v.ob[0] = 0;
                            quads[3].v.ob[1] = 0;
                            quads[3].v.ob[2] = 0;
 
                            quads[0].v.tc[0] = 0;
                            quads[0].v.tc[1] = 0;
 
                            quads[1].v.tc[0] = (width / 2) * 32;
                            quads[1].v.tc[1] = 0;
 
                            quads[2].v.tc[0] = 0;
                            quads[2].v.tc[1] = (height / 2) * 32;
 
                            quads[3].v.tc[0] = (width / 2) * 32;
                            quads[3].v.tc[1] = (height / 2) * 32;
                            break;
                        case 1:
                            quads[4].v.ob[0] = 0;
                            quads[4].v.ob[1] = -height / 2;
                            quads[4].v.ob[2] = 0;
 
                            quads[5].v.ob[0] = (-width / 2) + width;
                            quads[5].v.ob[1] = -height / 2;
                            quads[5].v.ob[2] = 0;
 
                            quads[6].v.ob[0] = 0;
                            quads[6].v.ob[1] = 0;
                            quads[6].v.ob[2] = 0;
 
                            quads[7].v.ob[0] = (-width / 2) + width;
                            quads[7].v.ob[1] = 0;
                            quads[7].v.ob[2] = 0;
 
                            quads[4].v.tc[0] = (width / 2) * 32;
                            quads[4].v.tc[1] = 0;
 
                            quads[5].v.tc[0] = width * 32;
                            quads[5].v.tc[1] = 0;
 
                            quads[6].v.tc[0] = (width / 2) * 32;
                            quads[6].v.tc[1] = (height / 2) * 32;
 
                            quads[7].v.tc[0] = width * 32;
                            quads[7].v.tc[1] = (height / 2) * 32;
 
#ifndef SHIFT
                            quads += 4;
#endif
                            break;
                        case 2:
                            quads[8].v.ob[0] = -width / 2;
                            quads[8].v.ob[1] = 0;
                            quads[8].v.ob[2] = 0;
 
                            quads[9].v.ob[0] = 0;
                            quads[9].v.ob[1] = 0;
                            quads[9].v.ob[2] = 0;
 
                            quads[10].v.ob[0] = -width / 2;
                            quads[10].v.ob[1] = height / 2;
                            quads[10].v.ob[2] = 0;
 
                            quads[11].v.ob[0] = 0;
                            quads[11].v.ob[1] = height / 2;
                            quads[11].v.ob[2] = 0;
 
                            quads[8].v.tc[0] = 0;
                            quads[8].v.tc[1] = (height / 2) * 32;
 
                            quads[9].v.tc[0] = (width / 2) * 32;
                            quads[9].v.tc[1] = (height / 2) * 32;
 
                            quads[10].v.tc[0] = 0;
                            quads[10].v.tc[1] = height * 32;
 
                            quads[11].v.tc[0] = (width / 2) * 32;
                            quads[11].v.tc[1] = height * 32;
 
#ifndef SHIFT
                            quads += 8;
#endif
                            break;
                        case 3:
                            quads[12].v.ob[0] = 0;
                            quads[12].v.ob[1] = 0;
                            quads[12].v.ob[2] = 0;
 
                            quads[13].v.ob[0] = (-width / 2) + width;
                            quads[13].v.ob[1] = 0;
                            quads[13].v.ob[2] = 0;
 
                            quads[14].v.ob[0] = 0;
                            quads[14].v.ob[1] = height / 2;
                            quads[14].v.ob[2] = 0;
 
                            quads[15].v.ob[0] = (-width / 2) + width;
                            quads[15].v.ob[1] = height / 2;
                            quads[15].v.ob[2] = 0;
 
                            quads[12].v.tc[0] = (width / 2) * 32;
                            quads[12].v.tc[1] = (height / 2) * 32;
 
                            quads[13].v.tc[0] = width * 32;
                            quads[13].v.tc[1] = (height / 2) * 32;
 
                            quads[14].v.tc[0] = (width / 2) * 32;
                            quads[14].v.tc[1] = height * 32;
 
                            quads[15].v.tc[0] = width * 32;
                            quads[15].v.tc[1] = height * 32;
 
#ifndef SHIFT
                            quads += 12;
#endif
                            break;
                    }
#ifdef SHIFT
                    gSPVertex(gMainGfxPos++, &quads[idx*4], 4, 0);
#else
                    gSPVertex(gMainGfxPos++, quads, 4, 0);
#endif
                    gSP2Triangles(gMainGfxPos++, 0, 3, 1, 0, 0, 2, 3, 0);
                } else {
                    switch (idx) {
                        case 0:
                            gSPScisTextureRectangle(gMainGfxPos++, posX * 4, posY * 4, (posX + width / 2) * 4, (posY + height / 2) * 4, G_TX_RENDERTILE, 0, 0, 0x400, 0x400);
                            break;
                        case 1:
                            gSPScisTextureRectangle(gMainGfxPos++, (posX + width / 2) * 4, posY * 4, (posX + width) * 4, (posY + height / 2) * 4, G_TX_RENDERTILE, (width / 2) * 32, 0, 0x400, 0x400);
                            break;
                        case 2:
                            gSPScisTextureRectangle(gMainGfxPos++, posX * 4, (posY + height / 2) * 4, (posX + width / 2) * 4, (posY + height) * 4, G_TX_RENDERTILE, 0, (height / 2) * 32, 0x400, 0x400);
                            break;
                        case 3:
                            gSPScisTextureRectangle(gMainGfxPos++, (posX + width / 2) * 4, (posY + height / 2) * 4, (posX + width) * 4, (posY + height) * 4, G_TX_RENDERTILE, (width / 2) * 32, (height / 2) * 32, 0x400, 0x400);
                            break;
                    }
 
                }
                gDPPipeSync(gMainGfxPos++);
            }
        } else if (bgImage != NULL) {
            if (quads != NULL) {
                quads[0].v.ob[0] = -width / 2;
                quads[0].v.ob[1] = -height / 2;
                quads[0].v.ob[2] = 0;
 
                quads[1].v.ob[0] = (-width / 2) + width;
                quads[1].v.ob[1] = -height / 2;
                quads[1].v.ob[2] = 0;
 
                quads[2].v.ob[0] = -width / 2;
                quads[2].v.ob[1] = height / 2;
                quads[2].v.ob[2] = 0;
 
                quads[3].v.ob[0] = (-width / 2) + width;
                quads[3].v.ob[1] = height / 2;
                quads[3].v.ob[2] = 0;
 
                quads[0].v.tc[0] = 0;
                quads[0].v.tc[1] = 0;
 
                quads[1].v.tc[1] = 0;
                quads[1].v.tc[0] = width * 32;
 
                quads[2].v.tc[0] = 0;
                quads[2].v.tc[1] = height * 32;
 
                quads[3].v.tc[0] = width * 32;
                quads[3].v.tc[1] = height * 32;
 
                gSPVertex(gMainGfxPos++, &quads[0], 4, 0);
                gSP2Triangles(gMainGfxPos++, 0, 3, 1, 0, 0, 2, 3, 0);
            } else {
                gSPScisTextureRectangle(gMainGfxPos++, posX * 4, posY * 4, (posX + width) * 4, (posY + height) * 4, G_TX_RENDERTILE, 0, 0, 0x0400, 0x0400);
            }
            gDPPipeSync(gMainGfxPos++);
        }
 
        gDPSetTexturePersp(gMainGfxPos++, G_TP_NONE);
        gDPSetCycleType(gMainGfxPos++, G_CYC_1CYCLE);
        if(fpDrawContents != NULL) {
            if (quads != NULL) {
                void* mdl_address = mdl_get_next_texture_address(width * height * 2);
                if(mdl_address != 0) {
                    gDPSetColorImage(gMainGfxPos++, G_IM_FMT_RGBA, G_IM_SIZ_16b, width, OS_K0_TO_PHYSICAL(mdl_address));
                    gDPSetScissor(gMainGfxPos++, G_SC_NON_INTERLACE, 0, 0, width, height);
                    gDPSetCycleType(gMainGfxPos++, G_CYC_FILL);
                    gDPSetFillColor(gMainGfxPos++, PACK_FILL_COLOR(primR, primG, primB, 0));
                    gDPSetRenderMode(gMainGfxPos++, G_RM_NOOP, G_RM_NOOP2);
                    gDPFillRectangle(gMainGfxPos++, 0, 0, width - 1, height - 1);
                    gDPPipeSync(gMainGfxPos++);
                    gDPSetScissorFrac(gMainGfxPos++, G_SC_NON_INTERLACE, 4, 4, (width - 1) * 4.0f, (height - 1) * 4.0f);
                    gDPSetCycleType(gMainGfxPos++, G_CYC_1CYCLE);
 
                    fpDrawContents((s32)drawContentsArg0, 0, 0, width, height, opacity, darkening);
 
                    gDPPipeSync(gMainGfxPos++);
                    gDPSetColorImage(gMainGfxPos++, G_IM_FMT_RGBA, G_IM_SIZ_16b, 320, OS_K0_TO_PHYSICAL(nuGfxCfb_ptr));
                    gDPSetScissor(gMainGfxPos++, G_SC_NON_INTERLACE, 0, 0, 320, 240);
                    gSPViewport(gMainGfxPos++, &gBoxViewport);
                    gSPMatrix(gMainGfxPos++, sp154, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
                    gSPTexture(gMainGfxPos++, 0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON);
                    gDPSetCycleType(gMainGfxPos++, G_CYC_1CYCLE);
                    gDPSetTextureLUT(gMainGfxPos++, G_TT_NONE);
                    gDPSetCombineMode(gMainGfxPos++, G_CC_DECALRGBA, G_CC_DECALRGBA);
                    gDPSetRenderMode(gMainGfxPos++, G_RM_CLD_SURF, G_RM_NOOP2);
                    gDPSetTexturePersp(gMainGfxPos++, G_TP_PERSP);
                    gDPSetTextureFilter(gMainGfxPos++, G_TF_BILERP);
                    guTranslateF(mtx3, 0.0f, 6.0f, 0.0f);
                    guMtxF2L(mtx3, &gBoxMatrix);
                    guTranslateF(mtx3, 0.0f, -height / 2, 0.0f);
                    guMtxF2L(mtx3, &gDisplayContext->matrixStack[gMatrixListPos]);
                    gSPMatrix(gMainGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++], G_MTX_NOPUSH | G_MTX_MUL | G_MTX_MODELVIEW);
                    for (idx = 0; idx < height / 6; idx++) {
                        s32 extraHeight, lineHeight;
                        if (idx == height / 6 - 1) {
                            extraHeight = 0;
                            if (height % 6 != 0) {
                                extraHeight = 1;
                            }
                        } else {
                            extraHeight = 1;
                        }
                        lineHeight = extraHeight + 5;
                        gDPLoadTextureTile(gMainGfxPos++, OS_K0_TO_PHYSICAL(mdl_address), G_IM_FMT_RGBA, G_IM_SIZ_16b, width, 0,
                                        0, idx * 6, width - 1, idx * 6 + lineHeight, 0,
                                        G_TX_CLAMP, G_TX_CLAMP, 9, 3, G_TX_NOLOD, G_TX_NOLOD);
                        gDPSetTileSize(gMainGfxPos++, G_TX_RENDERTILE, (160 - width / 2) * 4, 0, ((160 - width / 2) + width - 1) * 4, lineHeight * 4);
                        gSPVertex(gMainGfxPos++, &vtx_drawbox1, 4, 0);
                        gSP2Triangles(gMainGfxPos++, 0, 3, 1, 0, 0, 2, 3, 0);
                        gDPPipeSync(gMainGfxPos++);
                        gSPMatrix(gMainGfxPos++, &gBoxMatrix, G_MTX_NOPUSH | G_MTX_MUL | G_MTX_MODELVIEW);
                    }
                }
            } else {
                fpDrawContents((s32)drawContentsArg0, posX, posY, width, height, opacity, darkening);
            }
        }
        if (quads != NULL) {
            gSPPopMatrix(gMainGfxPos++, G_MTX_MODELVIEW);
            gDPSetTexturePersp(gMainGfxPos++, G_TP_NONE);
            gDPPipeSync(gMainGfxPos++);
        }
        return FALSE;
    }
}

◆ get_msg_width()

s32 get_msg_width	(	s32	msgID,
		u16	charset )

Definition at line 1971 of file msg.c.

                                          {
    s32 width;
 
    get_msg_properties(msgID, NULL, &width, NULL, NULL, NULL, NULL, charset);
    return width;
}

◆ partner_can_open_world_menus()

s32 partner_can_open_world_menus ( void )

Definition at line 983 of file partners.c.

                                       {
    if (wPartner != NULL
        && wPartner->canPlayerOpenMenus != NULL
        && !wPartner->canPlayerOpenMenus(wPartnerNpc)
    ) {
        return FALSE;
    }
    return TRUE;
}

Referenced by can_open_world_menu(), and should_cancel_open_world_menu().

◆ disable_player_static_collisions()

s32 disable_player_static_collisions ( void )

Definition at line 972 of file 77480.c.

                                           {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    playerStatus->flags |= PS_FLAG_NO_STATIC_COLLISION;
    playerStatus->enableCollisionOverlapsCheck++;
    return playerStatus->enableCollisionOverlapsCheck;
}

Referenced by action_update_parasol(), action_update_use_munchlesia(), action_update_use_spinning_flower(), action_update_use_tweester(), entity_BlueWarpPipe_set_player_move_to_center(), entity_HiddenPanel_flip_over(), entity_StarBoxLauncher_check_launch(), and post_battle().

◆ disable_player_input()

s32 disable_player_input ( void )

Definition at line 990 of file 77480.c.

                               {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    playerStatus->flags |= PS_FLAG_INPUT_DISABLED;
    playerStatus->inputDisabledCount++;
    return playerStatus->inputDisabledCount;
}

Referenced by _use_partner_ability(), action_update_landing_on_switch(), action_update_spin_jump(), action_update_tornado_jump(), action_update_use_munchlesia(), action_update_use_spinning_flower(), action_update_use_tweester(), check_input_open_menus(), entity_BlueWarpPipe_set_player_move_to_center(), entity_Chest_idle(), entity_CymbalPlant_idle(), entity_HeartBlock_show_tutorial_message(), entity_HeartBlockContent_anim_idle(), entity_SaveBlock_pause_game(), entity_SimpleSpring_idle(), entity_TriggerBlock_disable_player_input(), func_802BC0B8_E2E9E8(), phys_player_land(), post_battle(), post_battle(), SentinelAI_Descend(), start_battle(), state_init_file_select(), state_init_pause(), state_step_change_map(), state_step_enter_world(), state_step_intro(), step_game_loop(), update_encounters_neutral(), and update_item_entity_pickup().

◆ func_80027088()

void func_80027088 ( s32 )

◆ set_time_freeze_mode()

void set_time_freeze_mode ( s32 mode )

Time freeze modes: 0: none 1: NPCs move, can't be interacted with 2: NPCs don't move, no partner ability, can't interact, can't use exits 3: NPCs don't more or animate 4: NPCs can move, animations don't update, can use exits.

Definition at line 358 of file main_loop.c.

                                    {
    switch (mode) {
        case TIME_FREEZE_NONE:
            gTimeFreezeMode = mode;
            gOverrideFlags &= ~(GLOBAL_OVERRIDES_800 | GLOBAL_OVERRIDES_400 | GLOBAL_OVERRIDES_200 | GLOBAL_OVERRIDES_DISABLE_BATTLES);
            resume_all_group(EVT_GROUP_FLAG_INTERACT | EVT_GROUP_FLAG_MENUS);
            break;
        case TIME_FREEZE_PARTIAL:
            gTimeFreezeMode = mode;
            gOverrideFlags &= ~(GLOBAL_OVERRIDES_800 | GLOBAL_OVERRIDES_400 | GLOBAL_OVERRIDES_200);
            gOverrideFlags |= GLOBAL_OVERRIDES_DISABLE_BATTLES;
            suspend_all_group(EVT_GROUP_FLAG_INTERACT);
            break;
        case TIME_FREEZE_FULL:
            gTimeFreezeMode = mode;
            gOverrideFlags &= ~(GLOBAL_OVERRIDES_400 | GLOBAL_OVERRIDES_800);
            gOverrideFlags |= GLOBAL_OVERRIDES_200 | GLOBAL_OVERRIDES_DISABLE_BATTLES;
            suspend_all_group(EVT_GROUP_FLAG_MENUS);
            break;
        case TIME_FREEZE_POPUP_MENU:
            gTimeFreezeMode = mode;
            gOverrideFlags &= ~GLOBAL_OVERRIDES_800;
            gOverrideFlags |= GLOBAL_OVERRIDES_400 | GLOBAL_OVERRIDES_200 | GLOBAL_OVERRIDES_DISABLE_BATTLES;
            suspend_all_group(EVT_GROUP_FLAG_MENUS);
            break;
        case TIME_FREEZE_EXIT:
            gTimeFreezeMode = mode;
            gOverrideFlags |= GLOBAL_OVERRIDES_800 | GLOBAL_OVERRIDES_400 | GLOBAL_OVERRIDES_200 | GLOBAL_OVERRIDES_DISABLE_BATTLES;
            break;
    }
}

Referenced by _use_partner_ability(), action_update_parasol(), check_input_open_menus(), entity_HeartBlock_show_tutorial_message(), entity_HeartBlock_wait_for_close_tutorial(), entity_HeartBlockContent__anim_heal(), entity_HeartBlockContent_anim_idle(), entity_HiddenPanel_flip_over(), entity_SaveBlock_pause_game(), entity_SaveBlock_resume_game(), pre_battle(), state_init_file_select(), state_init_pause(), state_step_battle(), state_step_change_map(), state_step_end_battle(), state_step_enter_world(), state_step_exit_file_select(), state_step_unpause(), and update_item_entity_pickup().

◆ get_map_IDs_by_name()

s32 get_map_IDs_by_name	(	const char *	mapName,
		s16 *	areaID,
		s16 *	mapID )

Definition at line 228 of file world.c.

                                                                                {
    s32 i;
    s32 j;
    MapConfig* maps;
 
    // TODO: Potentially a fake match? Difficult to not set the temp in the for conditional.
    for (i = 0; (maps = gAreas[i].maps) != NULL; i++) {
        for (j = 0; j < gAreas[i].mapCount; j++) {
            if (strcmp(maps[j].id, mapName) == 0) {
                *areaID = i;
                *mapID = j;
                return TRUE;
            }
        }
    }
 
    return FALSE;
}

Referenced by get_map_IDs_by_name_checked().

◆ get_map_IDs_by_name_checked()

void get_map_IDs_by_name_checked	(	const char *	mapName,
		s16 *	areaID,
		s16 *	mapID )

Same as get_map_IDs_by_name, but will panic if the map doesn't exist.

Definition at line 247 of file world.c.

                                                                               {
    ASSERT_MSG(get_map_IDs_by_name(mapName, areaID, mapID), "Map not found: %s", mapName);
}

Referenced by btl_state_update_end_battle(), filemenu_yesno_handle_input(), goto_map(), and state_step_demo().

◆ transform_point()

void transform_point	(	Matrix4f	mtx,
		f32	inX,
		f32	inY,
		f32	inZ,
		f32	inS,
		f32 *	outX,
		f32 *	outY,
		f32 *	outZ,
		f32 *	outW )

Definition at line 431 of file 43F0.c.

                                                                                                                   {
    *outX = (mtx[0][0] * inX) + (mtx[1][0] * inY) + (mtx[2][0] * inZ) + mtx[3][0];
    *outY = (mtx[0][1] * inX) + (mtx[1][1] * inY) + (mtx[2][1] * inZ) + mtx[3][1];
    *outZ = (mtx[0][2] * inX) + (mtx[1][2] * inY) + (mtx[2][2] * inZ) + mtx[3][2];
    *outW = (mtx[0][3] * inX) + (mtx[1][3] * inY) + (mtx[2][3] * inZ) + mtx[3][3];
}

◆ try_player_footstep_sounds()

void try_player_footstep_sounds ( s32 arg0 )

Definition at line 1105 of file 7BB60.c.

                                              {
    if (gGameStatusPtr->frameCounter % interval == 0) {
        s32 surfaceType = get_collider_flags(gCollisionStatus.curFloor) & COLLIDER_FLAGS_SURFACE_TYPE_MASK;
        s32 soundID, altSoundID;
 
        if (surfaceType == SURFACE_TYPE_FLOWERS || surfaceType == SURFACE_TYPE_HEDGES) {
            soundID = SOUND_STEP_CRUNCHY1;
            altSoundID = SOUND_STEP_CRUNCHY2;
        } else {
            soundID = SOUND_STEP_NORMAL1;
            altSoundID = SOUND_STEP_NORMAL2;
        }
 
        if (FootstepSoundSelector == 0) {
            soundID = altSoundID;
        }
 
        sfx_play_sound_at_player(soundID, SOUND_SPACE_DEFAULT);
        FootstepSoundSelector ^= 1;
    }
}

Referenced by action_update_run(), action_update_step_up_peach(), and action_update_walk().

◆ phys_update_interact_collider()

void phys_update_interact_collider ( void )

Definition at line 1127 of file 7BB60.c.

                                         {
    gCollisionStatus.curInspect = phys_check_interactable_collision();
}

Referenced by action_update_idle(), action_update_idle_peach(), action_update_peach_step_down(), action_update_run(), action_update_spin(), action_update_step_down(), and action_update_walk().

◆ phys_reset_spin_history()

void phys_reset_spin_history ( void )

Definition at line 95 of file 7E9D0.c.

                                   {
    s32 i;
 
    mem_clear(&gPlayerSpinState, sizeof(PlayerSpinState));
    gSpinHistoryBufferPos = 0;
 
    for (i = 0; i < ARRAY_COUNT(gSpinHistoryPosAngle); i++) {
        gSpinHistoryPosAngle[i] = 0;
        gSpinHistoryPosX[i] = 0;
        gSpinHistoryPosY[i] = 0;
        gSpinHistoryPosZ[i] = 0;
    }
 
    D_8010C964 = 0;
    LastLoadedActionOffset = NULL;
}

Referenced by reset_player_status().

◆ phys_adjust_cam_on_landing()

s32 phys_adjust_cam_on_landing ( void )

Definition at line 46 of file 7E9D0.c.

                                     {
    s32 ret = LANDING_CAM_CHECK_SURFACE;
 
    if (LandingAdjustCamCallback != NULL) {
        ret = LandingAdjustCamCallback();
    }
 
    if (ret == LANDING_CAM_CHECK_SURFACE) {
        s32 surfaceType = get_collider_flags(gCollisionStatus.curFloor) & COLLIDER_FLAGS_SURFACE_TYPE_MASK;
 
        if (surfaceType == SURFACE_TYPE_LAVA) {
            gCameras[CAM_DEFAULT].moveFlags |= CAMERA_MOVE_IGNORE_PLAYER_Y;
            ret = LANDING_CAM_NEVER_ADJUST;
        } else {
            gCameras[CAM_DEFAULT].moveFlags &= ~CAMERA_MOVE_IGNORE_PLAYER_Y;
        }
    } else if (gPartnerStatus.actingPartner == PARTNER_PARAKARRY && gPartnerStatus.partnerActionState != PARTNER_ACTION_NONE) {
        gCameras[CAM_DEFAULT].moveFlags |= CAMERA_MOVE_NO_INTERP_Y;
    } else {
        gCameras[CAM_DEFAULT].moveFlags &= ~CAMERA_MOVE_NO_INTERP_Y;
    }
 
    return ret;
}

Referenced by action_update_hit_lava(), action_update_jump(), action_update_land(), action_update_peach_land(), action_update_peach_step_down_land(), action_update_step_down_land(), action_update_step_up(), action_update_use_spinning_flower(), entity_CymbalPlant_idle(), phys_main_collision_below(), and phys_player_land().

◆ phys_should_player_be_sliding()

s32 phys_should_player_be_sliding ( void )

Definition at line 839 of file 7BB60.c.

                                        {
    if (PlayerSlidingCallback != NULL) {
        return PlayerSlidingCallback();
    }
    return FALSE;
}

Referenced by check_input_jump(), and phys_main_collision_below().

◆ phys_init_integrator_for_current_state()

void phys_init_integrator_for_current_state ( void )

Definition at line 272 of file 7BB60.c.

                                                  {
    switch (gPlayerStatus.actionState) {
        case ACTION_STATE_LANDING_ON_SWITCH:
            gPlayerStatus.gravityIntegrator[0] = 10.0f;
            gPlayerStatus.gravityIntegrator[1] = -5.0f;
            gPlayerStatus.gravityIntegrator[2] = 1.5f;
            gPlayerStatus.gravityIntegrator[3] = -0.3f;
            break;
        case ACTION_STATE_JUMP:
        case ACTION_STATE_SPIN_JUMP:
        case ACTION_STATE_SPIN_POUND:
        case ACTION_STATE_TORNADO_JUMP:
        case ACTION_STATE_TORNADO_POUND:
        case ACTION_STATE_HIT_FIRE:
        case ACTION_STATE_HIT_LAVA:
            if (!(gPlayerStatus.flags & PS_FLAG_ENTERING_BATTLE)) {
                gPlayerStatus.gravityIntegrator[0] = GravityParamsStartJump[0];
                gPlayerStatus.gravityIntegrator[1] = GravityParamsStartJump[1];
                gPlayerStatus.gravityIntegrator[2] = GravityParamsStartJump[2];
                gPlayerStatus.gravityIntegrator[3] = GravityParamsStartJump[3];
            } else {
                gPlayerStatus.gravityIntegrator[0] = GravityParamsStartJump[0] * 0.5f;
                gPlayerStatus.gravityIntegrator[1] = GravityParamsStartJump[1] * 0.5f;
                gPlayerStatus.gravityIntegrator[2] = GravityParamsStartJump[2] * 0.5f;
                gPlayerStatus.gravityIntegrator[3] = GravityParamsStartJump[3] * 0.5f;
            }
            break;
    }
}

Referenced by initialize_jump().

◆ phys_player_land()

void phys_player_land ( void )

Definition at line 369 of file 7BB60.c.

                            {
    PlayerStatus* playerStatus = &gPlayerStatus;
    CollisionStatus* collisionStatus = &gCollisionStatus;
    f32 moveAngle;
    f32 moveMagnitude;
 
    playerStatus->timeInAir = 0;
    playerStatus->peakJumpTime = 0;
    playerStatus->flags &= ~PS_FLAG_SCRIPTED_FALL;
    playerStatus->landPos.x = playerStatus->pos.x;
    playerStatus->landPos.z = playerStatus->pos.z;
    playerStatus->flags &= ~PS_FLAG_AIRBORNE;
    sfx_play_sound_at_player(SOUND_LAND_SOFTLY, SOUND_SPACE_DEFAULT);
    if (!(collisionStatus->curFloor & COLLISION_WITH_ENTITY_BIT)) {
        phys_adjust_cam_on_landing();
    }
 
    collisionStatus->lastTouchedFloor = -1;
    if (collisionStatus->curFloor & COLLISION_WITH_ENTITY_BIT) {
        s32 entityType = get_entity_type(collisionStatus->curFloor);
 
        if (entityType <= ACTION_STATE_FALLING) {
            if (entityType >= ACTION_STATE_LANDING_ON_SWITCH) {
                Entity* entity = get_entity_by_index(collisionStatus->curFloor);
 
                entity->collisionFlags |= ENTITY_COLLISION_PLAYER_TOUCH_FLOOR;
                if (playerStatus->actionState != ACTION_STATE_TORNADO_JUMP
                    && playerStatus->actionState != ACTION_STATE_TORNADO_POUND
                    && playerStatus->actionState != ACTION_STATE_SPIN_JUMP
                    && playerStatus->actionState != ACTION_STATE_SPIN_POUND
                ) {
                    set_action_state(ACTION_STATE_LANDING_ON_SWITCH);
                } else {
                    disable_player_input();
                    playerStatus->actionSubstate = 11;
                }
                return;
            }
        }
    }
 
    if (playerStatus->flags & PS_FLAG_CUTSCENE_MOVEMENT) {
        set_action_state(ACTION_STATE_RUN);
        return;
    }
 
    if (playerStatus->actionState == ACTION_STATE_LANDING_ON_SWITCH) {
        set_action_state(ACTION_STATE_BOUNCE_OFF_SWITCH);
        return;
    }
 
    player_input_to_move_vector(&moveAngle, &moveMagnitude);
    if (moveMagnitude == 0.0f) {
        if (playerStatus->actionState != ACTION_STATE_STEP_DOWN) {
            set_action_state(ACTION_STATE_LAND);
        } else {
            set_action_state(ACTION_STATE_STEP_DOWN_LAND);
        }
        return;
    }
 
    if (moveMagnitude != 0.0f) {
        playerStatus->targetYaw = moveAngle;
    }
    update_locomotion_state();
}

Referenced by action_update_tornado_jump(), handle_jumping_land_on_switch(), and player_handle_floor_collider_type().

◆ phys_main_collision_below()

void phys_main_collision_below ( void )

Definition at line 863 of file 7BB60.c.

                                     {
    PlayerStatus* playerStatus = &gPlayerStatus;
    PartnerStatus* partnerStatus = &gPartnerStatus;
    CollisionStatus* collisionStatus = &gCollisionStatus;
    f32 collHeightHalf = playerStatus->colliderHeight * 0.5f;
    f32 playerX = playerStatus->pos.x;
    f32 playerY = playerStatus->pos.y + collHeightHalf;
    f32 playerZ = playerStatus->pos.z;
    f32 outLength = playerStatus->colliderHeight;
    f32 temp_f24 = (2.0f * playerStatus->colliderHeight) / 7.0f;
    f32 hitRx, hitRz;
    f32 hitDirX, hitDirZ;
    s32 colliderID;
    s32 cond;
 
    colliderID = player_raycast_below_cam_relative(playerStatus, &playerX, &playerY, &playerZ, &outLength, &hitRx, &hitRz,
                                               &hitDirX, &hitDirZ);
    playerStatus->groundNormalPitch = get_player_normal_pitch();
 
    if (collHeightHalf + (temp_f24 * 0.5f) < outLength) {
        colliderID = NO_COLLIDER;
    }
    if (playerStatus->timeInAir == 0) {
        collisionStatus->curFloor = colliderID;
    }
    if (colliderID > NO_COLLIDER) {
        playerStatus->groundAnglesXZ.x = hitDirX;
        playerStatus->groundAnglesXZ.y = hitDirZ;
    }
 
    if (check_player_action_debug()) {
        return;
    }
 
    if (playerStatus->flags & PS_FLAG_AIRBORNE) {
        return;
    }
 
    if (playerStatus->actionState == ACTION_STATE_SLIDING) {
        return;
    }
 
    if (playerStatus->flags & PS_FLAG_SLIDING) {
        phys_adjust_cam_on_landing();
    }
 
    if (playerStatus->flags & PS_FLAG_SLIDING && phys_should_player_be_sliding()) {
        set_action_state(ACTION_STATE_SLIDING);
    }
 
    if (playerStatus->actionState == ACTION_STATE_SLIDING) {
        return;
    }
 
    if (colliderID > NO_COLLIDER) {
        s32 surfaceType = get_collider_flags(colliderID) & COLLIDER_FLAGS_SURFACE_TYPE_MASK;
        switch (surfaceType) {
            case SURFACE_TYPE_SPIKES:
                if (partnerStatus->partnerActionState == PARTNER_ACTION_NONE || partnerStatus->actingPartner != PARTNER_BOW) {
                    if (playerStatus->blinkTimer == 0) {
                        if (playerStatus->actionState != ACTION_STATE_HIT_LAVA) {
                            playerStatus->hazardType = HAZARD_TYPE_SPIKES;
                            set_action_state(ACTION_STATE_HIT_LAVA);
                        }
                    } else {
                        set_action_state(ACTION_STATE_KNOCKBACK);
                    }
                }
                break;
            case SURFACE_TYPE_LAVA:
                if (partnerStatus->partnerActionState == PARTNER_ACTION_NONE || partnerStatus->actingPartner != PARTNER_BOW) {
                    if (playerStatus->blinkTimer == 0) {
                        if (playerStatus->actionState != ACTION_STATE_HIT_LAVA) {
                            playerStatus->hazardType = HAZARD_TYPE_LAVA;
                            set_action_state(ACTION_STATE_HIT_LAVA);
                        }
                    } else {
                        set_action_state(ACTION_STATE_KNOCKBACK);
                    }
                }
                break;
            default:
                cond = FALSE;
                if (collisionStatus->curFloor & COLLISION_WITH_ENTITY_BIT) {
                    cond = get_entity_type(collisionStatus->curFloor) == ENTITY_TYPE_HIDDEN_PANEL;
                }
 
                if (playerStatus->actionState != ACTION_STATE_STEP_UP && !cond) {
                    if (!(playerStatus->animFlags & PA_FLAG_USING_PEACH_PHYSICS)) {
                        if (playerY - playerStatus->pos.y < 6.0f) {
                            playerStatus->pos.y = playerY;
                        } else {
                            set_action_state(ACTION_STATE_STEP_UP);
                            StepUpLastY = playerY;
                            StepUpLastYaw = playerStatus->targetYaw;
                        }
                    } else {
                        playerStatus->pos.y = playerY;
                    }
                    phys_save_ground_pos();
                }
                break;
        }
    } else if (!(playerStatus->flags & PS_FLAG_FLYING)
        && playerStatus->actionState != ACTION_STATE_USE_SPINNING_FLOWER
    ) {
        if (outLength <= collHeightHalf + temp_f24 && hitDirX == 0.0f && hitDirZ == 0.0f) {
            set_action_state(ACTION_STATE_STEP_DOWN);
        } else {
            set_action_state(ACTION_STATE_FALLING);
        }
        gravity_use_fall_parms();
    }
}

Referenced by phys_update_standard().

◆ phys_peach_update()

void phys_peach_update ( void )

Definition at line 182 of file 7E9D0.c.

                             {
    calculate_camera_yinterp_rate();
 
    do {
        if (!(gPlayerStatus.flags & PS_FLAG_PAUSED) && check_conversation_trigger()) {
            set_action_state(ACTION_STATE_TALK);
        }
 
        Action* action = &PlayerActionsTable[gPlayerStatus.actionState];
 
        if (action->flag) {
            if (gPlayerStatus.flags & PS_FLAG_ACTION_STATE_CHANGED) {
                if (action->dmaStart != NULL && action->dmaStart != LastLoadedActionOffset) {
                    LastLoadedActionOffset = action->dmaStart;
                    dma_copy(action->dmaStart, action->dmaEnd, PLAYER_ACTION_VRAM_DEF);
                }
            }
            action->update();
        }
    } while (gPlayerStatus.flags & PS_FLAG_ACTION_STATE_CHANGED);
 
    peach_check_for_parasol_input();
    if (gPlayerStatus.animFlags & PA_FLAG_INVISIBLE) {
        peach_sync_disguise_npc();
    }
}

Referenced by phys_update_action_state().

◆ check_input_spin()

void check_input_spin ( void )

Definition at line 386 of file 7E9D0.c.

                            {
    PlayerStatus* playerStatus = &gPlayerStatus;
    PlayerSpinState* spinState = &gPlayerSpinState;
    PlayerSpinState* temp2 = spinState;
 
    if (!((playerStatus->flags & (PS_FLAG_NO_STATIC_COLLISION | PS_FLAG_CUTSCENE_MOVEMENT)) ||
          (playerStatus->animFlags & PA_FLAG_USING_WATT) ||
          (playerStatus->curButtons & BUTTON_C_DOWN) ||
          is_ability_active(ABILITY_SLOW_GO))) {
 
        s32 actionState = playerStatus->actionState;
        s32 btnPressed = playerStatus->pressedButtons & Z_TRIG;
 
        // TODO
        if (actionState != ACTION_STATE_RIDE) {
            if (actionState < ACTION_STATE_STEP_UP) {
                if (actionState < ACTION_STATE_JUMP) {
                    if (actionState >= 0 && !(playerStatus->animFlags & PA_FLAG_SPINNING)) {
                        if (btnPressed || spinState->hasBufferedSpin) {
                            set_action_state(ACTION_STATE_SPIN);
                            if (spinState->hasBufferedSpin != FALSE) {
                                if (spinState->bufferedStickAxis.x != 0 || spinState->bufferedStickAxis.y != 0) {
                                    playerStatus->prevActionState = temp2->prevActionState;
                                } else {
                                    playerStatus->prevActionState = ACTION_STATE_IDLE;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

Referenced by phys_update_action_state().

◆ phys_set_player_sliding_check()

void phys_set_player_sliding_check ( b32(*)(void) funcPtr )

Definition at line 846 of file 7BB60.c.

                                                         {
    PlayerSlidingCallback = funcPtr;
}

Referenced by load_map_by_IDs().

◆ phys_set_landing_adjust_cam_check()

void phys_set_landing_adjust_cam_check ( s32(*)(void) funcPtr )

Definition at line 42 of file 7E9D0.c.

                                                             {
    LandingAdjustCamCallback = funcPtr;
}

Referenced by load_map_by_IDs().

◆ npc_test_move_simple_without_slipping()

b32 npc_test_move_simple_without_slipping	(	s32	ignoreFlags,
		f32 *	x,
		f32 *	y,
		f32 *	z,
		f32	length,
		f32	yaw,
		f32	height,
		f32	radius )

Definition at line 602 of file npc_collision.c.

                                                      {
    f32 tempX = *x;
    f32 tempY = *y + 10.01f;
    f32 tempZ = *z;
    s32 hitID = npc_test_move_without_slipping(ignoreFlags, &tempX, &tempY, &tempZ, fabsf(length), yaw, radius * 0.5f);
 
    *x = tempX;
    *z = tempZ;
 
    return hitID > NO_COLLIDER;
}

Referenced by AvoidPlayerAI_ChaseInit().

◆ update_collider_transform()

void update_collider_transform ( s16 colliderID )

Definition at line 391 of file collision.c.

                                               {
    Collider* collider;
    struct Model* model;
    Matrix4f matrix;
    s32 i;
    Vec3f* vertexTable;
    f32 min_x, min_y, min_z, max_x, max_y, max_z;
    ColliderTriangle* triangle;
    f32 e13_y, e21_z, e13_z, e21_y, e21_x, e13_x, normalX, normalY, normalZ, coeff;
 
    collider = &gCollisionData.colliderList[colliderID];
    model = get_model_from_list_index(collider->parentModelIndex);
 
    if (model->bakedMtx == NULL) {
        copy_matrix(model->userTransformMtx, matrix);
    } else {
        guMtxL2F(matrix, (Mtx*)model->bakedMtx);
        guMtxCatF(model->userTransformMtx, matrix, matrix);
    }
 
    triangle = collider->triangleTable;
    vertexTable = collider->vertexTable;
 
    min_x = min_y = min_z = 999999.9f;
    max_x = max_y = max_z = -999999.9f;
 
    for (i = 0; i < collider->numVertices; vertexTable += 2, i++) {
        guMtxXFMF(matrix, vertexTable[1].x, vertexTable[1].y, vertexTable[1].z, &vertexTable[0].x, &vertexTable[0].y, &vertexTable[0].z);
 
        if (vertexTable[0].x < min_x)
            min_x = vertexTable[0].x;
        if (vertexTable[0].x > max_x)
            max_x = vertexTable[0].x;
        if (vertexTable[0].y < min_y)
            min_y = vertexTable[0].y;
        if (vertexTable[0].y > max_y)
            max_y = vertexTable[0].y;
        if (vertexTable[0].z < min_z)
            min_z = vertexTable[0].z;
        if (vertexTable[0].z > max_z)
            max_z = vertexTable[0].z;
    }
 
    collider->aabb->min.x = min_x;
    collider->aabb->min.y = min_y;
    collider->aabb->min.z = min_z;
    collider->aabb->max.x = max_x;
    collider->aabb->max.y = max_y;
    collider->aabb->max.z = max_z;
 
    for (i = 0; i < collider->numTriangles; triangle++, i++) {
        Vec3f* v1 = triangle->v1;
        Vec3f* v2 = triangle->v2;
        Vec3f* v3 = triangle->v3;
 
        triangle->e13.x = v3->x - v1->x;
        triangle->e13.y = v3->y - v1->y;
        triangle->e13.z = v3->z - v1->z;
        triangle->e21.x = v1->x - v2->x;
        triangle->e21.y = v1->y - v2->y;
        triangle->e21.z = v1->z - v2->z;
        triangle->e32.x = v2->x - v3->x;
        triangle->e32.y = v2->y - v3->y;
        triangle->e32.z = v2->z - v3->z;
 
        e13_x = triangle->e13.x;
        e13_y = triangle->e13.y;
        e13_z = triangle->e13.z;
        e21_x = triangle->e21.x;
        e21_y = triangle->e21.y;
        e21_z = triangle->e21.z;
 
        // vector product
        normalX = e13_y * e21_z - e13_z * e21_y;
        normalY = e13_z * e21_x - e13_x * e21_z;
        normalZ = e13_x * e21_y - e13_y * e21_x;
        coeff  = SQ(normalX) + SQ(normalY) + SQ(normalZ);
 
        if (coeff != 0) {
            coeff = 1.0f / sqrtf(coeff);
        } else {
            coeff = 0.0f;
        }
 
        triangle->normal.x = normalX * coeff;
        triangle->normal.y = normalY * coeff;
        triangle->normal.z = normalZ * coeff;
    }
}

Referenced by restore_map_collision_data().

◆ get_collider_center()

void get_collider_center	(	s32	colliderID,
		f32 *	x,
		f32 *	y,
		f32 *	z )

Definition at line 497 of file collision.c.

                                                                 {
    ColliderBoundingBox* aabb = gCollisionData.colliderList[colliderID].aabb;
 
    *x = (aabb->min.x + aabb->max.x) * 0.5f;
    *y = (aabb->min.y + aabb->max.y) * 0.5f;
    *z = (aabb->min.z + aabb->max.z) * 0.5f;
}

◆ is_another_trigger_bound()

s32 is_another_trigger_bound	(	Trigger *	trigger,
		EvtScript *	script )

Definition at line 254 of file trigger.c.

                                                                  {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentTriggerListPtr); i++) {
        Trigger* listTrigger = (*gCurrentTriggerListPtr)[i];
 
        if (listTrigger == NULL || listTrigger == trigger) {
            continue;
        }
 
        if (listTrigger->flags & TRIGGER_ACTIVE) {
            if (listTrigger->flags & TRIGGER_ACTIVATED) {
                if (listTrigger->onTriggerEvt == script) {
                    return TRUE;
                }
            }
        }
    }
 
    return FALSE;
}

Referenced by evt_trigger_on_activate_exec_script().

◆ create_trigger()

Trigger * create_trigger ( TriggerBlueprint * def )

Definition at line 55 of file trigger.c.

                                              {
    Trigger* trigger;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentTriggerListPtr); i++) {
        Trigger* listTrigger = (*gCurrentTriggerListPtr)[i];
 
        if (listTrigger == NULL) {
            break;
        }
    }
 
    ASSERT(i < ARRAY_COUNT(*gCurrentTriggerListPtr));
 
    (*gCurrentTriggerListPtr)[i] = trigger = heap_malloc(sizeof(*trigger));
    gTriggerCount++;
 
    ASSERT(trigger != NULL);
 
    trigger->flags = bp->flags | TRIGGER_ACTIVE;
    trigger->varIndex = bp->varIndex;
    trigger->location.colliderID = bp->colliderID;
    trigger->itemList = bp->itemList;
    trigger->tattleMsg = bp->tattleMsg;
    trigger->hasPlayerInteractPrompt = bp->hasPlayerInteractPrompt;
 
    trigger->onActivateFunc = bp->onActivateFunc;
    if (trigger->onActivateFunc == NULL) {
        trigger->onActivateFunc = (s32 (*) (Trigger*)) default_trigger_on_activate;
    }
 
    return trigger;
}

Referenced by bind_trigger(), evt_handle_bind(), and evt_handle_bind_lock().

◆ evt_trigger_on_activate_exec_script()

s32 evt_trigger_on_activate_exec_script ( Trigger * trigger )

Definition at line 981 of file evt.c.

                                                          {
    EvtScript* scriptStart;
    Evt* script;
 
    if (trigger->runningScript == NULL) {
        scriptStart = trigger->onTriggerEvt;
        if (is_another_trigger_bound(trigger, scriptStart)) {
            return 0;
        }
 
        script = start_script(scriptStart, trigger->priority, EVT_FLAG_RUN_IMMEDIATELY);
        trigger->runningScript = script;
        trigger->runningScriptID = script->id;
        script->varTable[0] = trigger->varTable[0];
        script->varTable[1] = trigger->varTable[1];
        script->varTable[2] = trigger->varTable[2];
        script->owner2.trigger = trigger;
    }
 
    if (!does_script_exist(trigger->runningScriptID)) {
        trigger->runningScript = NULL;
        return 0; // stop calling this function
    }
 
    return 1; // keep calling this function every frame
}

Referenced by bind_trigger(), and evt_handle_bind().

◆ get_trigger_by_id()

Trigger * get_trigger_by_id ( s32 triggerID )

Definition at line 276 of file trigger.c.

                                          {
    return (*gCurrentTriggerListPtr)[triggerID];
}

Referenced by get_trigger_tattle().

◆ get_actor()

Actor * get_actor ( s32 actorID )

Definition at line 155 of file actor_api.c.

                              {
    Actor* ret = NULL;
    BattleStatus* battleStatus = &gBattleStatus;
    s32 actorClass = actorID & ACTOR_CLASS_MASK;
    u32 idIdx = (u8)actorID;
 
    switch (actorClass) {
        case ACTOR_CLASS_PLAYER:
            ret = battleStatus->playerActor;
            break;
        case ACTOR_CLASS_PARTNER:
            ret = battleStatus->partnerActor;
            break;
        case ACTOR_CLASS_ENEMY:
            ret = battleStatus->enemyActors[idIdx];
            break;
    }
    return ret;
}

Referenced by btl_state_draw_select_target(), btl_state_update_first_strike(), btl_state_update_next_enemy(), btl_state_update_partner_striking_first(), btl_state_update_select_target(), calc_enemy_damage_target(), calc_enemy_test_target(), calc_item_check_hit(), calc_item_damage_enemy(), calc_partner_damage_enemy(), calc_partner_test_enemy(), calc_player_damage_enemy(), calc_player_test_enemy(), clear_part_flag_bits(), create_part_shadow(), create_target_list(), get_cam_subject_properties(), remove_part_shadow(), set_actor_anim(), set_actor_anim_rate(), set_actor_current_position(), set_actor_home_position(), set_actor_yaw(), set_goal_pos_to_part(), set_part_absolute_position(), set_part_flag_bits(), set_part_goal_to_actor_part(), and set_part_yaw().

◆ get_actor_part()

ActorPart * get_actor_part	(	Actor *	actor,
		s32	partID )

Definition at line 1191 of file 190B20.c.

                                                    {
    ActorPart* part = &actor->partsTable[0];
 
    if (partID < 0 || part->nextPart == NULL) {
        return part;
    }
 
    while (part != NULL) {
        if (part->staticData->index == partID) {
            return part;
        }
        part = part->nextPart;
    }
 
    return NULL;
}

Referenced by btl_state_draw_select_target(), btl_state_update_select_target(), calc_enemy_damage_target(), calc_enemy_test_target(), calc_item_check_hit(), calc_item_damage_enemy(), calc_partner_damage_enemy(), calc_partner_test_enemy(), calc_player_damage_enemy(), calc_player_test_enemy(), clear_part_flag_bits(), create_part_shadow(), create_target_list(), get_cam_subject_properties(), remove_part_shadow(), set_actor_anim(), set_actor_anim_rate(), set_goal_pos_to_part(), set_part_absolute_position(), set_part_flag_bits(), set_part_goal_to_actor_part(), and set_part_yaw().

◆ add_coins()

s32 add_coins ( s32 amt )

Definition at line 2076 of file inventory.c.

                       {
    PlayerData* playerData = &gPlayerData;
    s16 newCoins = playerData->coins + amt;
 
    playerData->coins = newCoins;
    if (newCoins > 999) {
        playerData->coins = 999;
    }
    if (playerData->coins < 0) {
        playerData->coins = 0;
    }
 
    if (amt > 0) {
        playerData->totalCoinsEarned += amt;
        if (playerData->totalCoinsEarned > 99999) {
            playerData->totalCoinsEarned = 99999;
        }
    }
    return playerData->coins;
}

◆ is_partner_ability_active()

s32 is_partner_ability_active ( s32 ability )

Definition at line 2072 of file inventory.c.

                                           {
    return 0;
}

Referenced by player_team_is_ability_active().

◆ count_power_plus()

s32 count_power_plus ( s32 damageType )

Definition at line 939 of file 190B20.c.

                                     {
    s32 count;
    s32 i;
 
    if (gGameStatusPtr->peachFlags & PEACH_FLAG_IS_PEACH) {
        return 0;
    }
 
    count = 0;
    for (i = 0; i < ARRAY_COUNT(gPlayerData.equippedBadges); i++) {
        u8 moveID = gItemTable[gPlayerData.equippedBadges[i]].moveID;
 
        if (gMoveTable[moveID].category == MOVE_TYPE_ATTACK_UP && moveID == MOVE_POWER_PLUS) {
            if (gBattleStatus.flags1 & BS_FLAGS1_INCLUDE_POWER_UPS || damageType & DAMAGE_TYPE_JUMP) {
                count++;
            }
        }
    }
 
    return count;
}

Referenced by calc_player_damage_enemy().

◆ phys_can_player_interact()

s32 phys_can_player_interact ( void )

Definition at line 1159 of file 7BB60.c.

                                   {
    s32 ret = TRUE;
 
    if (gPartnerStatus.partnerActionState != PARTNER_ACTION_NONE) {
        if (gPartnerStatus.actingPartner == PARTNER_BOMBETTE) {
            if (gPartnerStatus.partnerActionState <= PARTNER_ACTION_BOMBETTE_2) {
                ret = FALSE;
            }
        } else {
            ret = FALSE;
        }
    } else if (!(gPlayerStatus.actionState == ACTION_STATE_IDLE ||
                 gPlayerStatus.actionState == ACTION_STATE_WALK ||
                 gPlayerStatus.actionState == ACTION_STATE_RUN)) {
        ret = FALSE;
    }
    return ret;
}

Referenced by check_for_interactables(), func_800E06D8(), should_collider_allow_interact(), should_continue_inspect(), and update_triggers().

◆ ai_enemy_play_sound()

void ai_enemy_play_sound	(	Npc *	npc,
		s32	arg1,
		s32	arg2 )

Definition at line 543 of file 23680.c.

                                                                     {
    Enemy* enemy = get_enemy(npc->npcID);
    s32 soundFlags = (upperSoundFlags & SOUND_SPACE_PARAMS_MASK) | SOUND_SPACE_FULL;
 
    if (upperSoundFlags & 1) {
        soundFlags |= SOUND_PARAM_MUTE;
    }
 
    if (enemy->npcSettings->actionFlags & AI_ACTION_20) {
        soundFlags |= SOUND_PARAM_CLIP_OFFSCREEN_ANY;
    }
 
    sfx_play_sound_at_position(soundID, soundFlags, npc->pos.x, npc->pos.y, npc->pos.z);
}

Referenced by basic_ai_chase(), basic_ai_found_player_jump_init(), basic_ai_loiter(), basic_ai_wander(), CleftAI_Hiding(), ClubbaNappingAI_Sleep(), FlyingAI_Loiter(), FlyingAI_Wander(), FlyingMagikoopaAI_11(), FlyingMagikoopaAI_21(), FlyingMagikoopaAI_23(), GuardAI_Idle(), GuardAI_ReturnHome(), HoppingAI_ChaseInit(), HoppingAI_Hop(), HoppingAI_HopInit(), HoppingAI_Loiter(), LakituAI_Loiter(), LakituAI_Wander(), MagikoopaAI_21(), MagikoopaAI_23(), ParatroopaAI_Windup(), PatrolAI_Loiter(), PatrolAI_Move(), PiranhaPlantAI_01(), PiranhaPlantAI_10(), and SentinelAI_ReturnHome().

◆ player_test_move_without_slipping()

HitID player_test_move_without_slipping	(	PlayerStatus *	playerStatus,
		f32 *	x,
		f32 *	y,
		f32 *	z,
		f32	length,
		f32	yaw,
		s32 *	hasClimbableStep )

Only used for Peach physics.

Definition at line 496 of file 77480.c.

                                                                                                                                        {
    f32 sinTheta;
    f32 cosTheta;
    f32 hitX;
    f32 hitY;
    f32 hitZ;
    f32 hitDepth;
    f32 hitNx;
    f32 hitNy;
    f32 hitNz;
    f32 slipDx;
    f32 slipDz;
    f32 depth;
    f32 radius;
    f32 depthDiff;
    f32 height;
    s32 ret;
    s32 hitID;
    f32 targetDx;
    f32 targetDz;
    f32 dx, dz;
 
    radius = playerStatus->colliderDiameter * 0.5f;
    height = playerStatus->colliderHeight * 0.286f;
    sin_cos_rad(DEG_TO_RAD(yaw), &sinTheta, &cosTheta);
 
    depth = length + radius;
    cosTheta = -cosTheta;
    hitDepth = depth;
    dx = radius * sinTheta;
    ret = NO_COLLIDER;
 
    hitID = player_raycast_general(PLAYER_COLLISION_0, *x, *y + 0.1, *z, sinTheta, 0, cosTheta, &hitX, &hitY, &hitZ, &hitDepth, &hitNx, &hitNy, &hitNz);
    if (hitID > NO_COLLIDER && hitDepth <= depth) {
        *hasClimbableStep = TRUE;
    }
 
    depth = length + radius;
    hitDepth = depth;
    dz = radius * cosTheta;
 
    hitID = player_raycast_general(PLAYER_COLLISION_0, *x, *y + height, *z, sinTheta, 0, cosTheta, &hitX, &hitY, &hitZ, &hitDepth, &hitNx, &hitNy, &hitNz);
 
    targetDx = 0.0f;
    targetDz = 0.0f;
 
    if (hitID > NO_COLLIDER && hitDepth <= depth) {
        depthDiff = hitDepth - depth;
        dx = depthDiff * sinTheta;
        dz = depthDiff * cosTheta;
        player_get_slip_vector(&slipDx, &slipDz, 0.0f, 0.0f, hitNx, hitNz);
        *x += dx + slipDx;
        *z += dz + slipDz;
        ret = hitID;
    }
    *x += targetDx;
    *z += targetDz;
    return ret;
}

Referenced by collision_lateral_peach().

◆ player_test_move_with_slipping()

HitID player_test_move_with_slipping	(	PlayerStatus *	playerStatus,
		f32 *	posX,
		f32 *	posY,
		f32 *	posZ,
		f32	speed,
		f32	heading )

Definition at line 563 of file 77480.c.

                                                                                                              {
    f32 sinTheta;
    f32 cosTheta;
    f32 hitX;
    f32 hitY;
    f32 hitZ;
    f32 hitDepth;
    f32 hitNx;
    f32 hitNy;
    f32 hitNz;
    f32 slipDx;
    f32 slipDz;
    f32 radius;
    f32 height;
    s32 hitID;
    f32 targetDx, targetDz;
    f32 dx, dz;
    f32 depthDiff;
    s32 ret = NO_COLLIDER;
 
    height = 0.0f;
    if (!(playerStatus->flags & (PS_FLAG_JUMPING | PS_FLAG_FALLING))) {
        height = 10.01f;
    }
    radius = playerStatus->colliderDiameter * 0.5f;
 
    sin_cos_rad(DEG_TO_RAD(yaw), &sinTheta, &cosTheta);
    cosTheta = -cosTheta;
    hitDepth = length + radius;
 
    targetDx = length * sinTheta;
    targetDz = length * cosTheta;
 
    hitID = player_raycast_general(PLAYER_COLLISION_0, *x, *y + height, *z, sinTheta, 0, cosTheta, &hitX, &hitY, &hitZ, &hitDepth, &hitNx, &hitNy, &hitNz);
    if (hitID > NO_COLLIDER && (depthDiff = hitDepth, depthDiff <= length + radius)) {
        depthDiff -= (length + radius);
        dx = depthDiff * sinTheta;
        dz = depthDiff * cosTheta;
        player_get_slip_vector(&slipDx, &slipDz, targetDx, targetDz, hitNx, hitNz);
        *x += dx + slipDx;
        *z += dz + slipDz;
        ret = hitID;
    } else {
        height = playerStatus->colliderHeight * 0.75;
        hitID = player_raycast_general(PLAYER_COLLISION_0, *x, *y + height, *z, sinTheta, 0, cosTheta, &hitX, &hitY, &hitZ, &hitDepth, &hitNx, &hitNy, &hitNz);
        if (hitID > NO_COLLIDER && (depthDiff = hitDepth, depthDiff <= length + radius)) {
            depthDiff -= (length + radius);
            dx = depthDiff * sinTheta;
            dz = depthDiff * cosTheta;
            player_get_slip_vector(&slipDx, &slipDz, targetDx, targetDz, hitNx, hitNz);
            *x += dx + slipDx;
            *z += dz + slipDz;
            ret = hitID;
        }
    }
 
    *x += targetDx;
    *z += targetDz;
    return ret;
}

Referenced by action_update_sliding(), collision_main_lateral(), and phys_check_interactable_collision().

◆ evt_get_variable()

s32 evt_get_variable	(	Evt *	script,
		Bytecode	var )

Definition at line 1689 of file evt.c.

                                                {
    s32 wordIdx;
    s32 bitIdx;
    s32 temp;
 
    if (var <= EVT_LIMIT) {
        return var;
    } else if (var <= EVT_IGNORE_ARG) {
        return var;
    } else if (var <= EVT_FIXED_CUTOFF) {
        return evt_fixed_var_to_float(var);
    } else if (var <= EVT_ARRAY_FLAG_CUTOFF) {
        var = EVT_INDEX_OF_ARRAY_FLAG(var);
        wordIdx = var / 32;
        bitIdx = var % 32;
        var = (script->flagArray[wordIdx] & (1 << bitIdx)) != 0;
        return var;
    } else if (var <= EVT_ARRAY_VAR_CUTOFF) {
        var = EVT_INDEX_OF_ARRAY_VAR(var);
        var = script->array[var];
        if (var > EVT_LIMIT) {
            if (var <= EVT_FIXED_CUTOFF){
                var = evt_fixed_var_to_float(var);
            }
        }
    } else if (var <= EVT_GAME_BYTE_CUTOFF) {
        var = EVT_INDEX_OF_GAME_BYTE(var);
        return get_global_byte(var);
    } else if (var <= EVT_AREA_BYTE_CUTOFF) {
        var = EVT_INDEX_OF_AREA_BYTE(var);
        return get_area_byte(var);
    } else if (var <= EVT_GAME_FLAG_CUTOFF) {
        var = EVT_INDEX_OF_GAME_FLAG(var);
        return get_global_flag(var);
    } else if (var <= EVT_AREA_FLAG_CUTOFF) {
        var = EVT_INDEX_OF_AREA_FLAG(var);
        return get_area_flag(var);
    } else if (var <= EVT_MAP_FLAG_CUTOFF) {
        var = EVT_INDEX_OF_MAP_FLAG(var);
        wordIdx = var;
        bitIdx = var % 32;
        var = (gMapFlags[wordIdx / 32] & (1 << bitIdx)) != 0;
        return var;
    } else if (var <= EVT_LOCAL_FLAG_CUTOFF) {
        var = EVT_INDEX_OF_LOCAL_FLAG(var);
        wordIdx = var;
        bitIdx = var % 32;
        var = (script->varFlags[wordIdx / 32] & (1 << bitIdx)) != 0;
        return var;
    } else if (var <= EVT_MAP_VAR_CUTOFF) {
        var = EVT_INDEX_OF_MAP_VAR(var);
        var = gMapVars[var];
        if (var > EVT_LIMIT) {
            temp = EVT_FIXED_CUTOFF;
            if (var <= temp){
                var = evt_fixed_var_to_float(var);
            }
        }
    } else if (var <= EVT_LOCAL_VAR_CUTOFF) {
        var = EVT_INDEX_OF_LOCAL_VAR(var);
        var = script->varTable[var];
        if (var > EVT_LIMIT) {
            temp = EVT_FIXED_CUTOFF;
            if (var <= temp){
                var = evt_fixed_var_to_float(var);
            }
        }
    }
        return var;
}

◆ evt_set_variable()

s32 evt_set_variable	(	Evt *	script,
		Bytecode	var,
		s32	value )

Definition at line 1846 of file evt.c.

                                                           {
    s32 flagBitPos;
    s32 oldValue;
 
    if (var <= EVT_LIMIT) {
        return value;
    } else if (var <= EVT_FIXED_CUTOFF) {
        return evt_fixed_var_to_float(value);
    } else if (var <= EVT_ARRAY_FLAG_CUTOFF) {
        var = EVT_INDEX_OF_ARRAY_FLAG(var);
        flagBitPos = var % 32;
        if (value) {
            script->flagArray[var / 32] |= 1 << flagBitPos;
        } else {
            script->flagArray[var / 32] &= ~(1 << flagBitPos);
        }
        return value;
    } else if (var <= EVT_ARRAY_VAR_CUTOFF) {
        var = EVT_INDEX_OF_ARRAY_VAR(var);
        oldValue = script->array[var];
        script->array[var] = value;
        return oldValue;
    } else if (var <= EVT_GAME_BYTE_CUTOFF) {
        var = EVT_INDEX_OF_GAME_BYTE(var);
        oldValue = get_global_byte(var);
        set_global_byte(var, value);
        return oldValue;
    } else if (var <= EVT_AREA_BYTE_CUTOFF) {
        var = EVT_INDEX_OF_AREA_BYTE(var);
        oldValue = get_area_byte(var);
        set_area_byte(var, value);
        return oldValue;
    } else if (var <= EVT_GAME_FLAG_CUTOFF) {
        var = EVT_INDEX_OF_GAME_FLAG(var);
        oldValue = get_global_flag(var);
        if (value) {
            set_global_flag(var);
        } else {
            clear_global_flag(var);
        }
        return oldValue;
    } else if (var <= EVT_AREA_FLAG_CUTOFF) {
        var = EVT_INDEX_OF_AREA_FLAG(var);
        oldValue = get_area_flag(var);
        if (value) {
            set_area_flag(var);
        } else {
            clear_area_flag(var);
        }
        return oldValue;
    } else if (var <= EVT_MAP_FLAG_CUTOFF) {
        var = EVT_INDEX_OF_MAP_FLAG(var);
        flagBitPos = var % 32;
        if (value) {
            gMapFlags[var / 32] |= 1 << flagBitPos;
        } else {
            gMapFlags[var / 32] &= ~(1 << flagBitPos);
        }
        return value;
    } else if (var <= EVT_LOCAL_FLAG_CUTOFF) {
        var = EVT_INDEX_OF_LOCAL_FLAG(var);
        flagBitPos = var % 32;
        if (value) {
            script->varFlags[var / 32] |= 1 << flagBitPos;
        } else {
            script->varFlags[var / 32] &= ~(1 << flagBitPos);
        }
        return value;
    } else if (var <= EVT_MAP_VAR_CUTOFF) {
        var = EVT_INDEX_OF_MAP_VAR(var);
        oldValue = gMapVars[var];
        gMapVars[var] = value;
        return oldValue;
    } else if (var <= EVT_LOCAL_VAR_CUTOFF) {
        var = EVT_INDEX_OF_LOCAL_VAR(var);
        oldValue = script->varTable[var];
        script->varTable[var] = value;
        return oldValue;
    } else {
        return value;
    }
}

Referenced by evt_handle_add(), evt_handle_allocate_array(), evt_handle_AND(), evt_handle_AND_const(), evt_handle_bind(), evt_handle_divide(), evt_handle_does_script_exist(), evt_handle_end_loop(), evt_handle_exec1_get_id(), evt_handle_get_1_word(), evt_handle_get_2_word(), evt_handle_get_3_word(), evt_handle_get_4_word(), evt_handle_get_Nth_word(), evt_handle_mod(), evt_handle_multiply(), evt_handle_OR(), evt_handle_OR_const(), evt_handle_set_const(), evt_handle_set_var(), evt_handle_subtract(), exec_ShakeCamX(), filemenu_yesno_handle_input(), init_enter_world_shared(), load_demo_battle(), state_step_demo(), and update_item_entity_pickup().

◆ evt_get_float_variable()

f32 evt_get_float_variable	(	Evt *	script,
		Bytecode	var )

Definition at line 1929 of file evt.c.

                                                      {
    s32 temp;
 
    if (var <= EVT_LIMIT) {
        return var;
    } else if (var <= EVT_IGNORE_ARG) {
        return var;
    } else if (var <= EVT_FIXED_CUTOFF) {
        return evt_fixed_var_to_float(var);
    } else if (var <= EVT_ARRAY_VAR_CUTOFF) {
        var = EVT_INDEX_OF_ARRAY_VAR(var);
        return evt_fixed_var_to_float(script->array[var]);
    } else if (var <= EVT_GAME_BYTE_CUTOFF) {
        var = EVT_INDEX_OF_GAME_BYTE(var);
        return evt_fixed_var_to_float(get_global_byte(var));
    } else if (var <= EVT_AREA_BYTE_CUTOFF) {
        var = EVT_INDEX_OF_AREA_BYTE(var);
        return evt_fixed_var_to_float(get_area_byte(var));
    } else if (var <= EVT_MAP_FLAG_CUTOFF) {
        var = EVT_INDEX_OF_MAP_FLAG(var);
        temp = var % 32;
        var = gMapFlags[var / 32] & (1 << temp);
        if (var) {
            return 1.0f;
        } else {
            return 0.0f;
        }
    } else if (var <= EVT_LOCAL_FLAG_CUTOFF) {
        var = EVT_INDEX_OF_LOCAL_FLAG(var);
        temp = var % 32;
        var = script->varFlags[var / 32] & (1 << temp);
        if (var) {
            return 1.0f;
        } else {
            return 0.0f;
        }
    } else if (var <= EVT_MAP_VAR_CUTOFF) {
        var = EVT_INDEX_OF_MAP_VAR(var);
        return evt_fixed_var_to_float(gMapVars[var]);
    } else if (var <= EVT_LOCAL_VAR_CUTOFF) {
        var = EVT_INDEX_OF_LOCAL_VAR(var);
        return evt_fixed_var_to_float(script->varTable[var]);
    } else {
        return evt_fixed_var_to_float(var);
    }
}

Referenced by evt_handle_addF(), evt_handle_divideF(), evt_handle_get_1_float(), evt_handle_get_2_float(), evt_handle_get_3_float(), evt_handle_get_4_float(), evt_handle_multiplyF(), evt_handle_set_float(), evt_handle_set_timescale(), evt_handle_subtractF(), evt_handle_wait_seconds(), and make_vine_interpolation().

◆ evt_set_float_variable()

f32 evt_set_float_variable	(	Evt *	script,
		Bytecode	var,
		f32	value )

Definition at line 1976 of file evt.c.

                                                                 {
    s32 temp;
    s32 oldValue;
 
    if (var <= EVT_LIMIT) {
        return value;
    } else if (var <= EVT_FIXED_CUTOFF) {
        return value;
    } else if (var <= EVT_ARRAY_VAR_CUTOFF) {
        var = EVT_INDEX_OF_ARRAY_VAR(var);
        oldValue = script->array[var];
        script->array[var] = evt_float_to_fixed_var(value);
        return evt_fixed_var_to_float(oldValue);
    } else if (var <= EVT_MAP_FLAG_CUTOFF) {
        var = EVT_INDEX_OF_MAP_FLAG(var);
        temp = var % 32;
        if (value) {
            gMapFlags[var / 32] |= 1 << temp;
        } else {
            gMapFlags[var / 32] &= ~(1 << temp);
        }
        return value;
    } else if (var <= EVT_LOCAL_FLAG_CUTOFF) {
        var = EVT_INDEX_OF_LOCAL_FLAG(var);
        temp = var % 32;
        if (value) {
            script->varFlags[var / 32] |= 1 << temp;
        } else {
            script->varFlags[var / 32] &= ~(1 << temp);
        }
        return value;
    } else if (var <= EVT_MAP_VAR_CUTOFF) {
        var = EVT_INDEX_OF_MAP_VAR(var);
        oldValue = gMapVars[var];
        gMapVars[var] = evt_float_to_fixed_var(value);
        return evt_fixed_var_to_float(oldValue);
    } else if (var <= EVT_LOCAL_VAR_CUTOFF) {
        var = EVT_INDEX_OF_LOCAL_VAR(var);
        oldValue = script->varTable[var];
        script->varTable[var] = evt_float_to_fixed_var(value);
        return evt_fixed_var_to_float(oldValue);
    } else {
        return value;
    }
}

Referenced by evt_handle_addF(), evt_handle_divideF(), evt_handle_get_1_float(), evt_handle_get_2_float(), evt_handle_get_3_float(), evt_handle_get_4_float(), evt_handle_get_Nth_float(), evt_handle_multiplyF(), evt_handle_set_float(), evt_handle_subtractF(), and exec_ShakeCamX().

◆ evt_get_variable_index()

s32 evt_get_variable_index	(	Evt *	script,
		s32	var )

Definition at line 1760 of file evt.c.

                                                 {
    if (EVT_LIMIT >= var) {
        return var;
    }
    if (EVT_IGNORE_ARG >= var) {
        return var;
    }
    if (EVT_FIXED_CUTOFF >= var) {
        return var;
    }
    if (EVT_ARRAY_FLAG_CUTOFF >= var) {
        return EVT_INDEX_OF_ARRAY_FLAG(var);
    }
    if (EVT_ARRAY_VAR_CUTOFF >= var) {
        return EVT_INDEX_OF_ARRAY_VAR(var);
    }
    if (EVT_GAME_BYTE_CUTOFF >= var) {
        return EVT_INDEX_OF_GAME_BYTE(var);
    }
    if (EVT_AREA_BYTE_CUTOFF >= var) {
        return EVT_INDEX_OF_AREA_BYTE(var);
    }
    if (EVT_GAME_FLAG_CUTOFF >= var) {
        return EVT_INDEX_OF_GAME_FLAG(var);
    }
    if (EVT_AREA_FLAG_CUTOFF >= var) {
        return EVT_INDEX_OF_AREA_FLAG(var);
    }
    if (EVT_MAP_FLAG_CUTOFF >= var) {
        return EVT_INDEX_OF_MAP_FLAG(var);
    }
    if (EVT_LOCAL_FLAG_CUTOFF >= var) {
        return EVT_INDEX_OF_LOCAL_FLAG(var);
    }
    if (EVT_MAP_VAR_CUTOFF >= var) {
        return EVT_INDEX_OF_MAP_VAR(var);
    }
    if (EVT_LOCAL_VAR_CUTOFF >= var) {
        return EVT_INDEX_OF_LOCAL_VAR(var);
    }
    return var;
}

Referenced by evt_handle_bind(), and evt_handle_bind_lock().

◆ set_script_timescale()

void set_script_timescale	(	Evt *	script,
		f32	timescale )

Definition at line 715 of file script_list.c.

                                                      {
    script->timeScale = timescale * GlobalTimeRate;
}

Referenced by evt_handle_set_timescale().

◆ sin_deg()

f32 sin_deg ( f32 x )

Definition at line 726 of file 43F0.c.

                       {
    return sins(_wrap_trig_lookup_value(DEG_TO_BINANG(theta))) * SHT_MINV;
}

◆ cos_deg()

f32 cos_deg ( f32 x )

Definition at line 730 of file 43F0.c.

                       {
    return coss(_wrap_trig_lookup_value(DEG_TO_BINANG(theta))) * SHT_MINV;
}

◆ sin_rad()

f32 sin_rad ( f32 x )

Definition at line 712 of file 43F0.c.

                       {
    return sins(_wrap_trig_lookup_value(RAD_TO_BINANG(theta))) * SHT_MINV;
}

Referenced by action_hammer_play_hit_fx(), action_update_hit_lava(), action_update_parasol(), action_update_spin(), action_update_use_spinning_flower(), action_update_use_tweester(), add_part_decor_steam(), add_xz_vec3f(), add_xz_vec3f_copy1(), add_xz_vec3f_copy2(), appendGfx_background_texture(), apply_constraints_to_lead_amount(), btl_state_update_9(), btl_state_update_end_player_turn(), btl_state_update_end_turn(), btl_state_update_partner_menu(), btl_state_update_peach_menu(), btl_state_update_player_menu(), btl_state_update_twink_menu(), btl_state_update_victory(), ChompChainAddPolarPos(), ChompChainGetPolarX(), create_camera_leadplayer_matrix(), Entity_BoardedFloor_update_fragments(), entity_BombableRock_update_fragments(), entity_Chest_close(), entity_Chest_open(), entity_GiantChest_give_equipment(), entity_GiantChest_open(), entity_HeartBlockContent__anim_heal(), entity_HiddenPanel_flip_over(), entity_inactive_block_hit_anim(), entity_inactive_block_recoil_anim(), entity_Padlock_push_player(), entity_StarBoxLauncher_launch(), entity_TrumpetPlant_create_effect(), entity_TrumpetPlant_spawn_coin(), entity_Tweester_move(), entity_WoodenCrate_update_fragments(), func_802BC3E4_E2ED14(), interp_lookat_pos(), npc_do_other_npc_collision(), npc_do_player_collision(), npc_move_heading(), npc_raycast_down_around(), npc_raycast_down_sides(), npc_raycast_up_corners(), play_movement_dust_effects(), player_raycast_up_corners(), sfx_compute_spatialized_sound_params_ignore_depth(), sync_held_position(), unkVtxFunc001(), update_camera_interp_pos(), update_camera_no_interp(), update_camera_unused_ahead(), update_camera_unused_confined(), update_camera_unused_radial(), update_item_entity_collectable(), update_lerp(), update_lerp_battle(), and virtual_entity_move_polar().

◆ cos_rad()

f32 cos_rad ( f32 x )

Definition at line 716 of file 43F0.c.

                       {
    return coss(_wrap_trig_lookup_value(RAD_TO_BINANG(theta))) * SHT_MINV;
}

Referenced by action_hammer_play_hit_fx(), action_update_hit_lava(), action_update_parasol(), action_update_spin(), add_part_decor_steam(), add_xz_vec3f(), add_xz_vec3f_copy1(), add_xz_vec3f_copy2(), apply_constraints_to_lead_amount(), ChompChainAddPolarPos(), ChompChainGetPolarX(), create_camera_leadplayer_matrix(), Entity_BoardedFloor_update_fragments(), entity_BombableRock_update_fragments(), entity_GiantChest_give_equipment(), entity_GiantChest_open(), entity_HeartBlockContent__anim_heal(), entity_Padlock_push_player(), entity_StarBoxLauncher_launch(), entity_TrumpetPlant_create_effect(), entity_TrumpetPlant_spawn_coin(), entity_Tweester_move(), entity_WoodenCrate_update_fragments(), interp_lookat_pos(), npc_do_other_npc_collision(), npc_do_player_collision(), npc_move_heading(), npc_raycast_down_around(), npc_raycast_down_sides(), npc_raycast_up_corners(), play_movement_dust_effects(), player_raycast_up_corners(), sync_held_position(), unkVtxFunc001(), update_camera_interp_pos(), update_camera_no_interp(), update_camera_unused_ahead(), update_camera_unused_confined(), update_camera_unused_radial(), update_camera_zone_interp(), update_item_entity_collectable(), update_lerp(), update_lerp_battle(), and virtual_entity_move_polar().

◆ round()

s32 round ( f32 x )

Definition at line 571 of file 43F0.c.

                 {
    if (!(x >= 0.0f)) {
        return -(s32)(0.5 - x);
    } else {
        return (s32)(0.5 + x);
    }
}

Referenced by atan2().

◆ atan2()

f32 atan2	(	f32	startX,
		f32	startZ,
		f32	endX,
		f32	endZ )

Definition at line 616 of file 43F0.c.

                                                      {
    f32 dx = endX - startX;
    f32 dz = endZ - startZ;
    f32 absXDiff = fabsf(dx);
    f32 absZDiff = fabsf(dz);
    f32 ret;
 
    if (absZDiff < absXDiff) {
        ret = (absZDiff / absXDiff) * 45.0f;
        ret *= sAtanFactors[round(2.0f * ret)];
        if (dx >= 0.0f) {
            if (dz >= 0.0f) {
                return ret + 90.0f;
            } else {
                return 90.0f - ret;
            }
        }
        if (dz >= 0.0f) {
            return 270.0f - ret;
        } else {
            return ret + 270.0f;
        }
    } else {
        if (absZDiff == 0.0f) {
            return 0.0f;
        }
        ret = (absXDiff / absZDiff) * 45.0f;
        ret *= sAtanFactors[round(2.0f * ret)];
        if (dz >= 0.0f) {
            if (dx >= 0.0f) {
                return 180.0f - ret;
            } else {
                return ret + 180.0f;
            }
        } else if (!(dx >= 0.0f)) {
            return 360.0f - ret;
        }
    }
    return ret;
}

◆ clamp_angle()

f32 clamp_angle ( f32 theta )

Definition at line 579 of file 43F0.c.

                           {
    if (fabsf(theta) > 3600.0f) {
        s32 thetaInt = theta;
 
        if (thetaInt >= 0) {
            thetaInt = -(thetaInt / 360 * 360) + thetaInt;
        } else {
            thetaInt = -thetaInt;
            thetaInt = (thetaInt / 360 * 360) - thetaInt;
        }
 
        return thetaInt;
    }
 
    do {
        if (theta < 0.0f) {
            theta += 360.0f;
        }
        if (theta >= 360.0f) {
            theta -= 360.0f;
        }
    } while (!(theta >= 0.0f) || !(theta < 360.0f));
 
    return theta;
}

◆ sign()

s32 sign ( s32 value )

Definition at line 375 of file 43F0.c.

                  {
    s32 sign = -1;
 
    if (val >= 0) {
        sign = val > 0;
    }
    return sign;
}

Referenced by imgfx_mesh_make_wavy(), pause_interp_text_scroll(), pause_interp_vertical_scroll(), pause_partners_update(), pause_tabs_update(), show_immune_bonk(), sign(), and signF().

◆ check_player_action_debug()

b32 check_player_action_debug ( void )

Definition at line 1016 of file 77480.c.

                                    {
    if (gGameStatusPtr->debugScripts != DEBUG_SCRIPTS_NONE && (gGameStatusPtr->curButtons[0] & BUTTON_R)) {
        if (gPartnerStatus.partnerActionState == PARTNER_ACTION_NONE) {
            set_action_state(ACTION_STATE_IDLE);
        }
        return TRUE;
    }
    return FALSE;
}

Referenced by phys_main_collision_below(), player_fall_distance(), and update_player().

◆ battle_heap_create()

s32 battle_heap_create ( void )

Definition at line 22 of file heap.c.

                             {
    if ((s32)_heap_create(&heap_battleHead, BATTLE_HEAP_SIZE) == -1) {
        return -1;
    } else {
        return 0;
    }
}

Referenced by battle_heap_create_obfuscated(), state_step_end_battle(), state_step_file_select(), and state_step_pause().

◆ test_ray_zones()

s32 test_ray_zones	(	f32	startX,
		f32	startY,
		f32	startZ,
		f32	dirX,
		f32	dirY,
		f32	dirZ,
		f32 *	hitX,
		f32 *	hitY,
		f32 *	hitZ,
		f32 *	hitDepth,
		f32 *	nx,
		f32 *	ny,
		f32 *	nz )

Definition at line 866 of file collision.c.

                                                                                                    {
    Collider* collider;
    CollisionData* collisionData;
    ColliderTriangle* triangle;
    s32 i, j;
    s32 colliderID;
 
    collisionData = &gZoneCollisionData;
    gCollisionRayDirX = dirX;
    gCollisionRayDirY = dirY;
    gCollisionRayDirZ = dirZ;
    gCollisionRayStartX = startX;
    gCollisionRayStartY = startY;
    gCollisionRayStartZ = startZ;
    gCollisionRayLength = *hitDepth;
    colliderID = NO_COLLIDER;
 
    for (i = 0; i < collisionData->numColliders; i++) {
        collider = &collisionData->colliderList[i];
 
        if (collider->flags & COLLIDER_FLAG_IGNORE_PLAYER)
            continue;
 
        if (collider->numTriangles == 0 || collider->aabb == NULL)
            continue;
 
        triangle = collider->triangleTable;
        for (j = 0; j < collider->numTriangles; j++) {
            if (test_ray_triangle_down(triangle++, collisionData->vertices)) {
                colliderID = i;
            }
        }
    }
 
    if (colliderID > NO_COLLIDER) {
        *hitX = gCollisionPointX;
        *hitY = gCollisionPointY;
        *hitZ = gCollisionPointZ;
        *hitDepth = gCollisionRayLength;
        *hitNx = gCollisionNormalX;
        *hitNy = gCollisionNormalY;
        *hitNz = gCollisionNormalZ;
        return colliderID;
    } else {
        return colliderID;
    }
}

Referenced by test_ray_zone(), and test_ray_zone_aabb().

◆ test_ray_colliders()

s32 test_ray_colliders	(	s32	ignoreFlags,
		f32	startX,
		f32	startY,
		f32	startZ,
		f32	dirX,
		f32	dirY,
		f32	dirZ,
		f32 *	hitX,
		f32 *	hitY,
		f32 *	hitZ,
		f32 *	hitDepth,
		f32 *	hitNx,
		f32 *	hitNy,
		f32 *	hitNz )

Definition at line 768 of file collision.c.

                                                                                                           {
    Collider* collider;
    CollisionData* collisionData;
    ColliderTriangle* triangle;
    s32 i, j;
    s32 colliderID;
    f32 min_x, min_y, min_z, max_x, max_y, max_z;
 
    if (dirX == 0 && dirY == 0 && dirZ == 0) {
        return 0;
    }
 
    collisionData = &gCollisionData;
    gCollisionRayDirX = dirX;
    gCollisionRayDirY = dirY;
    gCollisionRayDirZ = dirZ;
    gCollisionRayStartX = startX;
    gCollisionRayStartY = startY;
    gCollisionRayStartZ = startZ;
    gCollisionRayLength = *hitDepth;
    colliderID = NO_COLLIDER;
 
    if (dirX < 0) {
        min_x = startX + dirX * gCollisionRayLength;
        max_x = startX;
    } else {
        min_x = startX;
        max_x = startX + dirX * gCollisionRayLength;
    }
 
    if (dirY < 0) {
        min_y = startY + dirY * gCollisionRayLength;
        max_y = startY;
    } else {
        min_y = startY;
        max_y = startY + dirY * gCollisionRayLength;
    }
 
    if (dirZ < 0) {
        min_z = startZ + dirZ * gCollisionRayLength;
        max_z = startZ;
    } else {
        min_z = startZ;
        max_z = startZ + dirZ * gCollisionRayLength;
    }
 
    for (i = 0; i < collisionData->numColliders; i++) {
        collider = &collisionData->colliderList[i];
 
        if ((collider->flags & ignoreFlags) ||
            collider->numTriangles == 0     ||
            max_x < collider->aabb->min.x   ||
            min_x > collider->aabb->max.x   ||
            max_z < collider->aabb->min.z   ||
            min_z > collider->aabb->max.z   ||
            max_y < collider->aabb->min.y   ||
            min_y > collider->aabb->max.y)
        {
            continue;
        }
 
        triangle = collider->triangleTable;
        if (gCollisionRayDirX == 0 && gCollisionRayDirZ == 0 && gCollisionRayDirY == -1.0) {
            for (j = 0; j < collider->numTriangles; j++) {
                if (test_ray_triangle_down(triangle++, collisionData->vertices)) {
                    colliderID = i;
                }
            }
        } else if (gCollisionRayDirY == 0) {
            for (j = 0; j < collider->numTriangles; j++) {
                if (test_ray_triangle_horizontal(triangle++, collisionData->vertices)) {
                    colliderID = i;
                }
            }
        } else {
            for (j = 0; j < collider->numTriangles; j++) {
                if (test_ray_triangle_general(triangle++, collisionData->vertices)) {
                    colliderID = i;
                }
            }
        }
    }
 
    if (colliderID > NO_COLLIDER) {
        *hitX = gCollisionPointX;
        *hitY = gCollisionPointY;
        *hitZ = gCollisionPointZ;
        *hitDepth = gCollisionRayLength;
        *hitNx = gCollisionNormalX;
        *hitNy = gCollisionNormalY;
        *hitNz = gCollisionNormalZ;
        return colliderID;
    } else {
        return colliderID;
    }
}

Referenced by entity_raycast_down(), npc_raycast_down(), npc_raycast_general(), npc_raycast_up(), npc_raycast_up_corner(), player_raycast_down(), player_raycast_general(), player_raycast_up_corner(), and test_ray_to_wall_center().

◆ test_ray_entities()

s32 test_ray_entities	(	f32	startX,
		f32	startY,
		f32	startZ,
		f32	dirX,
		f32	dirY,
		f32	dirZ,
		f32 *	hitX,
		f32 *	hitY,
		f32 *	hitZ,
		f32 *	hitDepth,
		f32 *	hitNx,
		f32 *	hitNy,
		f32 *	hitNz )

Test a general ray from a given starting position and direction against all entities.

If one is hit, returns the position and normal of the hit and the length along the ray on the output params. All output params are invalid when a value of NO_COLLIDER is returned.

Parameters

	startX	origin x position of the ray
	startY	origin y position of the ray
	startZ	origin z position of the ray
	dirX	normalized x direction of the ray
	dirY	normalized y direction of the ray
	dirZ	normalized z direction of the ray
[out]	hitX	normalized x position of the hit
[out]	hitY	normalized y position of the hit
[out]	hitZ	normalized z position of the hit
[in,out]	hitDepth	as input, maximum length of the ray; as output, distance along the ray of the hit
[out]	hitNx	x normal direction of the hit
[out]	hitNy	y normal direction of the hit
[out]	hitNz	z normal direction of the hit

Returns: entity index or NO_COLLIDER is none is hit

Definition at line 947 of file collision.c.

                                                                                                          {
    f32 hitDepthDown, hitDepthHoriz;
    s32 type;
    s32 i, j;
    Entity* entity;
    Matrix4f tempMatrix1;
    Matrix4f tempMatrix2;
    Vec3f boxVertices[8];
    ColliderTriangle entityTriangle;
    s32 entityIndex;
    f32 h;
    f32 aabbX, aabbZ;
    s32 hasCollision;
    f32 dist, dist2;
    ColliderTriangle *triangle = &entityTriangle;
 
    enum {
        ENTITY_TEST_ANY     = 0,
        ENTITY_TEST_DOWN    = 1,
        ENTITY_TEST_LATERAL = 2,
    };
 
    entityIndex = NO_COLLIDER;
    type = ENTITY_TEST_ANY;
    hitDepthDown = hitDepthHoriz = *hitDepth;
 
    if (dirX == 0 && dirZ == 0 && dirY < 0) {
        hitDepthHoriz = 0;
        type = ENTITY_TEST_DOWN;
    } else if (dirY == 0) {
        hitDepthDown = 0;
        type = ENTITY_TEST_LATERAL;
    }
 
    gCollisionRayLength = -1;
    triangle->oneSided = TRUE;
    for (i = 0; i < MAX_ENTITIES; i++) {
        entity = get_entity_by_index(i);
 
        if (entity == NULL || (entity->flags & (ENTITY_FLAG_SKIP_UPDATE | ENTITY_FLAG_DISABLE_COLLISION))) {
            continue;
        }
 
        dist = hitDepthHoriz + entity->effectiveSize;
        if (startX > entity->pos.x + dist || startX < entity->pos.x - dist) {
            continue;
        }
 
        if (startZ > entity->pos.z + dist || startZ < entity->pos.z - dist) {
            continue;
        }
 
        switch (type) {
            case ENTITY_TEST_ANY:
            case ENTITY_TEST_DOWN:
                dist = entity->pos.y;
                dist2 = hitDepthDown + entity->effectiveSize * 2;
                if (dist + dist2 < startY || startY < dist - dist2) {
                    continue;
                }
                break;
            case ENTITY_TEST_LATERAL:
                dist = entity->pos.y;
                dist2 = entity->effectiveSize * 2;
                if (dist + dist2 < startY || startY < dist - dist2) {
                    continue;
                }
                break;
        }
 
        aabbX = entity->aabb.x / 2;
        aabbZ = entity->aabb.z / 2;
 
        boxVertices[1].x = boxVertices[2].x = boxVertices[5].x = boxVertices[6].x = -aabbX;
        boxVertices[0].x = boxVertices[3].x = boxVertices[4].x = boxVertices[7].x = aabbX;
        boxVertices[0].y = boxVertices[1].y = boxVertices[2].y = boxVertices[3].y = 0;
        boxVertices[4].y = boxVertices[5].y = boxVertices[6].y = boxVertices[7].y = entity->aabb.y;
        boxVertices[0].z = boxVertices[1].z = boxVertices[4].z = boxVertices[5].z = aabbZ;
        boxVertices[2].z = boxVertices[3].z = boxVertices[6].z = boxVertices[7].z = -aabbZ;
 
        guMtxXFMF(entity->inverseTransformMatrix, dirX, dirY, dirZ, &gCollisionRayDirX, &gCollisionRayDirY, &gCollisionRayDirZ);
        guMtxXFMF(entity->inverseTransformMatrix, startX - entity->pos.x, startY - entity->pos.y,
                  startZ - entity->pos.z, &gCollisionRayStartX, &gCollisionRayStartY, &gCollisionRayStartZ);
 
        for (j = 0; j < 12; j++) {
            Vec3f* v1 = triangle->v1 = &boxVertices[gEntityColliderFaces[j].x];
            Vec3f* v2 = triangle->v2 = &boxVertices[gEntityColliderFaces[j].y];
            Vec3f* v3 = triangle->v3 = &boxVertices[gEntityColliderFaces[j].z];
            triangle->e13.x = v3->x - v1->x;
            triangle->e13.y = v3->y - v1->y;
            triangle->e13.z = v3->z - v1->z;
            triangle->e21.x = v1->x - v2->x;
            triangle->e21.y = v1->y - v2->y;
            triangle->e21.z = v1->z - v2->z;
            triangle->e32.x = v2->x - v3->x;
            triangle->e32.y = v2->y - v3->y;
            triangle->e32.z = v2->z - v3->z;
            triangle->normal.x = gEntityColliderNormals[j].x;
            triangle->normal.y = gEntityColliderNormals[j].y;
            triangle->normal.z = gEntityColliderNormals[j].z;
 
            if (hasCollision = test_ray_triangle_general(&entityTriangle, boxVertices)) {
                break;
            }
        }
 
        if (hasCollision && gCollisionRayLength < *hitDepth) {
            entityIndex = i;
            *hitDepth = gCollisionRayLength;
 
            switch (type) {
                case ENTITY_TEST_ANY:
                    hitDepthDown = gCollisionRayLength;
                    hitDepthHoriz = gCollisionRayLength;
                    break;
                case ENTITY_TEST_DOWN:
                    hitDepthDown = gCollisionRayLength;
                    break;
                case ENTITY_TEST_LATERAL:
                    hitDepthHoriz = gCollisionRayLength;
                    break;
            }
 
            guRotateF(tempMatrix1, entity->rot.x, 1.0f, 0.0f, 0.0f);
            guRotateF(tempMatrix2, entity->rot.z, 0.0f, 0.0f, 1.0f);
            guMtxCatF(tempMatrix1, tempMatrix2, tempMatrix1);
            guRotateF(tempMatrix2, entity->rot.y, 0.0f, 1.0f, 0.0f);
            guMtxCatF(tempMatrix1, tempMatrix2, tempMatrix1);
            guTranslateF(tempMatrix2, entity->pos.x, entity->pos.y, entity->pos.z);
            guMtxCatF(tempMatrix1, tempMatrix2, tempMatrix1);
            guMtxXFMF(tempMatrix1, gCollisionPointX, gCollisionPointY, gCollisionPointZ, hitX, hitY, hitZ);
 
            h = 1.0f / sqrtf(SQ(gCollisionNormalX) + SQ(gCollisionNormalY) + SQ(gCollisionNormalZ));
            *hitNx = gCollisionNormalX * h;
            *hitNy = gCollisionNormalY * h;
            *hitNz = gCollisionNormalZ * h;
        }
    }
 
    return entityIndex;
}

Referenced by entity_raycast_down(), npc_raycast_down(), npc_raycast_general(), npc_raycast_up(), npc_raycast_up_corner(), player_raycast_down(), player_raycast_general(), and player_raycast_up_corner().

◆ mem_clear()

void mem_clear	(	void *	data,
		s32	numBytes )

Definition at line 422 of file 43F0.c.

                                         {
    u8* addressableData = data;
 
    while (numBytes > 0) {
        *addressableData++ = 0;
        numBytes--;
    }
}

◆ startup_set_fade_screen_color()

void startup_set_fade_screen_color ( s16 color )

Definition at line 7 of file startup_screen_fading.c.

                                              {
    gGameStatusPtr->screenColorB = color;
    gGameStatusPtr->screenColorG = color;
    gGameStatusPtr->screenColorR = color;
}

Referenced by btl_update(), state_init_intro(), state_init_logos(), state_step_demo(), state_step_logos(), and state_step_title_screen().

◆ startup_set_fade_screen_alpha()

void startup_set_fade_screen_alpha ( s16 alpha )

Definition at line 3 of file startup_screen_fading.c.

                                              {
    gGameStatusPtr->screenColorA = alpha;
}

Referenced by btl_update(), state_init_intro(), state_init_logos(), state_step_demo(), and state_step_logos().

◆ get_xz_dist_to_player()

f32 get_xz_dist_to_player	(	f32	x,
		f32	z )

Definition at line 960 of file 77480.c.

                                        {
    return dist2D(x, z, gPlayerStatus.pos.x, gPlayerStatus.pos.z);
}

Referenced by action_update_hit_fire(), action_update_hit_lava(), action_update_knockback(), entity_BlueWarpPipe_set_player_move_to_center(), and entity_HiddenPanel_idle().

◆ func_800E06C0()

void func_800E06C0 ( s32 arg0 )

Definition at line 1160 of file 77480.c.

                             {
    D_8010C950 = (arg0 == 1);
}

Referenced by update_triggers().

◆ close_status_bar()

void close_status_bar ( void )

Definition at line 1451 of file inventory.c.

                            {
    StatusBar* statusBar = &gStatusBar;
 
    if (statusBar->hidden != TRUE) {
        statusBar->hidden = TRUE;
        statusBar->showTimer = 0;
        statusBar->unk_3B = TRUE;
    }
}

Referenced by check_conversation_trigger(), check_input_status_bar(), destroy_popup_menu(), initialize_status_bar(), and shop_close_item_select_popup().

◆ func_802C39F8()

Evt * func_802C39F8	(	Evt *	parentScript,
		Bytecode *	nextLine,
		s32	newState )

Definition at line 419 of file script_list.c.

                                                                        {
    Evt* child;
    s32 curScriptIndex;
    s32 i;
    s32 scriptListCount;
 
    for (i = 0; i < MAX_SCRIPTS; i++) {
        if ((*gCurrentScriptListPtr)[i] == NULL) {
            break;
        }
    }
 
    ASSERT(i < MAX_SCRIPTS);
    curScriptIndex = i;
 
    (*gCurrentScriptListPtr)[curScriptIndex] = child = heap_malloc(sizeof(*child));
    gNumScripts++;
    ASSERT(child != NULL);
 
    child->stateFlags = newState | EVT_FLAG_ACTIVE;
    child->ptrNextLine = nextLine;
    child->ptrFirstLine = nextLine;
    child->ptrCurLine = nextLine;
    child->curOpcode = EVT_OP_INTERNAL_FETCH;
    child->userData = NULL;
    child->blockingParent = NULL;
    child->parentScript = parentScript;
    child->childScript = NULL;
    child->priority = parentScript->priority;
    child->id = UniqueScriptCounter++;
    child->owner1.actorID = parentScript->owner1.actorID;
    child->owner2.npcID = parentScript->owner2.npcID;
    child->loopDepth = -1;
    child->switchDepth = -1;
    child->groupFlags = parentScript->groupFlags;
    child->ptrSavedPos = NULL;
    child->array = parentScript->array;
    child->flagArray = parentScript->flagArray;
    child->timeScale = GlobalTimeRate;
    child->frameCounter = 0.0f;
    child->unk_158 = 0;
 
    scriptListCount = 0;
 
    for (i = 0; i < ARRAY_COUNT(child->varTable); i++) {
        child->varTable[i] = parentScript->varTable[i];
    }
 
    for (i = 0; i < ARRAY_COUNT(child->varFlags); i++) {
        child->varFlags[i] = parentScript->varFlags[i];
    }
 
    find_script_labels(child);
    if (IsUpdatingScripts) {
        scriptListCount = gScriptListCount++;
        gScriptIndexList[scriptListCount] = curScriptIndex;
        gScriptIdList[scriptListCount] = child->id;
    }
 
    if (UniqueScriptCounter == 0) {
        UniqueScriptCounter = 1;
    }
 
    suspend_frozen_scripts(child);
    return child;
}

Referenced by evt_handle_child_thread().

◆ start_child_script()

Evt * start_child_script	(	Evt *	parentScript,
		EvtScript *	source,
		s32	initialState )

Definition at line 350 of file script_list.c.

                                                                         {
    s32 curScriptIndex;
    s32 scriptListCount;
    Evt* child;
    s32 i;
 
    for (i = 0; i < MAX_SCRIPTS; i++) {
        if ((*gCurrentScriptListPtr)[i] == NULL) {
            break;
        }
    }
 
    ASSERT(i < MAX_SCRIPTS);
    curScriptIndex = i;
 
    (*gCurrentScriptListPtr)[curScriptIndex] = child = heap_malloc(sizeof(*child));
    gNumScripts++;
    ASSERT(child != NULL);
 
    parentScript->childScript = child;
    parentScript->stateFlags |= EVT_FLAG_BLOCKED_BY_CHILD;
    child->stateFlags = flags | EVT_FLAG_ACTIVE;
    child->ptrCurLine = child->ptrFirstLine = child->ptrNextLine = (Bytecode*)source;
 
    child->curOpcode = EVT_OP_INTERNAL_FETCH;
    child->userData = NULL;
    child->blockingParent = parentScript;
    child->childScript = NULL;
    child->parentScript = NULL;
    child->priority = parentScript->priority + 1;
    child->id = UniqueScriptCounter++;
    child->owner1 = parentScript->owner1;
    child->owner2 = parentScript->owner2;
    child->loopDepth = -1;
    child->switchDepth = -1;
    child->groupFlags = parentScript->groupFlags;
    child->ptrSavedPos = NULL;
    child->array = parentScript->array;
    child->flagArray = parentScript->flagArray;
    child->timeScale = GlobalTimeRate;
    child->frameCounter = 0.0f;
    child->unk_158 = 0;
 
    scriptListCount = 0;
 
    for (i = 0; i < ARRAY_COUNT(child->varTable); i++) {
        child->varTable[i] = parentScript->varTable[i];
    }
 
    for (i = 0; i < ARRAY_COUNT(child->varFlags); i++) {
        child->varFlags[i] = parentScript->varFlags[i];
    }
 
    find_script_labels(child);
    if (IsUpdatingScripts) {
        scriptListCount = gScriptListCount++;
        gScriptIndexList[scriptListCount] = curScriptIndex;
        gScriptIdList[scriptListCount] = child->id;
    }
 
    suspend_frozen_scripts(child);
 
    if (UniqueScriptCounter == 0) {
        UniqueScriptCounter = 1;
    }
 
    return child;
}

Referenced by evt_handle_exec_wait().

◆ restart_script()

Evt * restart_script ( Evt * script )

Definition at line 527 of file script_list.c.

                                 {
    Bytecode* ptrFirstLine = script->ptrFirstLine;
 
    // frameCounter gets set to 0 twice which makes me think a macro is being used here
    script->loopDepth = -1;
    script->switchDepth = -1;
    script->frameCounter = 0;
    script->curOpcode = EVT_OP_INTERNAL_FETCH;
 
    script->ptrNextLine = ptrFirstLine;
    script->ptrCurLine = ptrFirstLine;
    script->timeScale = 1.0f;
    script->frameCounter = 0;
    script->unk_158 = 0;
 
    script->timeScale = GlobalTimeRate;
 
    find_script_labels(script);
    suspend_frozen_scripts(script);
 
    return script;
}

Referenced by btl_cam_move(), and evt_handle_jump().

◆ clear_virtual_entity_list()

void clear_virtual_entity_list ( void )

Definition at line 652 of file virtual_entity.c.

                                     {
    s32 i;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentVirtualEntityListPtr = &wWorldVirtualEntityList;
    } else {
        gCurrentVirtualEntityListPtr = &bBattleVirtualEntityList;
    }
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentVirtualEntityListPtr); i++) {
        (*gCurrentVirtualEntityListPtr)[i] = heap_malloc(sizeof(VirtualEntity));
        ASSERT((*gCurrentVirtualEntityListPtr)[i] != NULL);
        (*gCurrentVirtualEntityListPtr)[i]->entityModelIndex = -1;
    }
 
    create_worker_scene(virtual_entity_list_update, virtual_entity_list_render_world);
    create_worker_backUI(NULL, virtual_entity_list_render_UI);
}

Referenced by clear_script_list().

◆ reset_model_animators()

void reset_model_animators ( void )

Definition at line 258 of file model_api.c.

                                 {
    s32 i;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD ) {
        gCurrentMeshAnimationListPtr = &gWorldMeshAnimationList;
    } else {
        gCurrentMeshAnimationListPtr = &gBattleMeshAnimationList;
    }
 
    for (i = 0; i < MAX_ANIMATED_MODELS; i++) {
        AnimatedModel* model = heap_malloc(sizeof(*model));
 
        (*gCurrentMeshAnimationListPtr)[i] = model;
        ASSERT((*gCurrentMeshAnimationListPtr)[i] != NULL);
        (*gCurrentMeshAnimationListPtr)[i]->animModelID = -1;
    }
 
    create_worker_scene(update_animated_models, render_animated_models);
}

Referenced by clear_script_list().

◆ init_virtual_entity_list()

void init_virtual_entity_list ( void )

Definition at line 671 of file virtual_entity.c.

                                    {
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentVirtualEntityListPtr = &wWorldVirtualEntityList;
    } else {
        gCurrentVirtualEntityListPtr = &bBattleVirtualEntityList;
    }
}

Referenced by init_script_list().

◆ init_model_animators()

void init_model_animators ( void )

Definition at line 278 of file model_api.c.

                                {
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentMeshAnimationListPtr = &gWorldMeshAnimationList;
    } else {
        gCurrentMeshAnimationListPtr = &gBattleMeshAnimationList;
    }
}

Referenced by init_script_list().

◆ play_model_animation()

void play_model_animation	(	s32	index,
		s16 *	animPos )

Definition at line 1101 of file animator.c.

                                                   {
    ModelAnimator* animator = (*gCurrentAnimMeshListPtr)[index & ~BATTLE_ID_BIT];
 
    if (animator->animationBuffer != NULL) {
        animPos = (s16*) (((s32)animPos & 0xFFFFFF) + (s32)animator->animationBuffer); // TODO: array access? / cleanup
    }
    animator->animReadPos = animPos;
    animator->savedReadPos = animPos;
    animator->treeIndexPos = 0;
    animator->nextUpdateTime = 1.0f;
}

Referenced by entity_BellbellPlant_idle(), entity_CymbalPlant_idle(), entity_HitItemBlock_play_anim(), entity_PinkFlower_idle(), entity_ScriptSpring_idle(), entity_SimpleSpring_idle(), entity_TrumpetPlant_idle(), and func_802BC0B8_E2E9E8().

◆ heap_free()

s32 heap_free ( void * ptr )

Definition at line 42 of file heap.c.

                          {
    if (gGameStatusPtr->context != CONTEXT_WORLD) {
        return _heap_free(&heap_battleHead, data);
    } else {
        return general_heap_free(data);
    }
}

Referenced by ALT_clear_hud_element_cache(), btl_bonk_update(), btl_delete_actor(), btl_delete_player_actor(), btl_popup_messages_delete(), delete_entity(), delete_entity_and_unload_data(), delete_model_animator(), delete_model_animator_node(), delete_shadow(), delete_trigger(), disable_npc_blur(), dispose_merlee_message(), free_animator_nodes(), free_animator_nodes_helper(), free_entity_model_by_index(), free_npc(), free_npc_by_index(), free_popup(), free_worker(), func_80045B10(), func_802C3C10(), get_asset_offset(), hud_element_free(), hud_element_free_transform(), imgfx_mesh_anim_update(), imgfx_update(), imgfx_update_cache_impl(), kill_enemy(), kill_script(), load_asset_by_name(), load_battle_hit_asset(), load_map_hit_asset(), load_path_data(), remove_item_entity_by_index(), remove_item_entity_by_reference(), and state_step_logos().

◆ load_battle_hit_asset()

void load_battle_hit_asset ( const char * hitName )

Definition at line 166 of file collision.c.

                                                {
    if (hitName == NULL) {
        gCollisionData.numColliders = 0;
    } else {
        u32 assetSize;
        MapSettings* map = get_current_map_settings();
        void* compressedData = load_asset_by_name(hitName, &assetSize);
        HitFile* uncompressedData = heap_malloc(assetSize);
 
        decode_yay0(compressedData, uncompressedData);
        general_heap_free(compressedData);
 
        map->hitAssetCollisionOffset = uncompressedData->collisionOffset;
 
        load_hit_data(0, uncompressedData);
 
        heap_free(uncompressedData);
    }
}

Referenced by btl_state_update_normal_start().

◆ load_data_for_models()

void load_data_for_models	(	struct ModelNode *	model,
		s32	romOffset,
		s32	size )

Definition at line 3318 of file model.c.

                                                                              {
    Matrix4f mtx;
 
    guMtxIdentF(mtx);
 
    if (texturesOffset != 0) {
        mdl_load_all_textures(rootModel, texturesOffset, size);
    }
 
    *gCurrentModelTreeRoot = rootModel;
    TreeIterPos = 0;
 
    if (rootModel != NULL) {
        load_model_transforms(rootModel, NULL, mtx, 0);
    }
}

Referenced by btl_state_update_normal_start(), and load_map_by_IDs().

◆ load_player_actor()

void load_player_actor ( void )

Definition at line 1208 of file 190B20.c.

                             {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player;
    ActorPart* part;
    DecorationTable* decorations;
    ActorPartMovement* partMovement;
    s32 i;
    s32 j;
 
    player = battleStatus->playerActor = heap_malloc(sizeof(*player));
 
    ASSERT(player != NULL);
 
    player->unk_134 = battleStatus->unk_93++;
    player->footStepCounter = 0;
    player->flags = 0;
    player->actorBlueprint = &bPlayerActorBlueprint;
    player->actorType = bPlayerActorBlueprint.type;
 
    if ((gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) || (gGameStatusPtr->demoBattleFlags & DEMO_BTL_FLAG_PARTNER_ACTING)) {
        player->homePos.x = player->curPos.x = -130.0f;
        player->homePos.y = player->curPos.y = 0.0f;
        player->homePos.z = player->curPos.z = -10.0f;
    } else {
        player->homePos.x = player->curPos.x = -95.0f;
        player->homePos.y = player->curPos.y = 0.0f;
        player->homePos.z = player->curPos.z = 0.0f;
    }
 
    player->headOffset.x = 0;
    player->headOffset.y = 0;
    player->headOffset.z = 0;
    player->rot.x = 0.0f;
    player->rot.y = 0.0f;
    player->rot.z = 0.0f;
    player->rotPivotOffset.x = 0;
    player->rotPivotOffset.y = 0;
    player->rotPivotOffset.z = 0;
    player->verticalRenderOffset = 0;
    player->yaw = 0.0f;
    player->renderMode = RENDER_MODE_ALPHATEST;
    player->scale.x = 1.0f;
    player->scale.y = 1.0f;
    player->scale.z = 1.0f;
    player->scaleModifier.x = 1.0f;
    player->scaleModifier.y = 1.0f;
    player->scaleModifier.z = 1.0f;
    player->size.x = player->actorBlueprint->size.x;
    player->size.y = player->actorBlueprint->size.y;
    player->actorID = 0;
    player->healthBarPos.x = player->curPos.x;
    player->healthBarPos.y = player->curPos.y;
    player->healthBarPos.z = player->curPos.z;
    player->scalingFactor = 1.0f;
    player->attackResultEffect = NULL;
    player->actionRatingCombo = 0;
    player->actionRatingTime = 0;
    player->statusIconOffset.x = 0;
    player->statusIconOffset.y = 0;
    player->statusTextOffset.x = 0;
    player->statusTextOffset.y = 0;
    player->idleSource = NULL;
    player->takeTurnSource = NULL;
    player->handleEventSource = NULL;
    player->handlePhaseSource = NULL;
    player->idleScript = NULL;
    player->takeTurnScript = NULL;
    player->handleEventScript = NULL;
    player->handlePhaseScript = NULL;
    player->turnPriority = 0;
    player->statusTable = bPlayerStatusTable;
    player->debuff = 0;
    player->debuffDuration = 0;
    player->staticStatus = 0;
    player->staticDuration = 0;
    player->stoneStatus = 0;
    player->stoneDuration = 0;
    player->koStatus = 0;
    player->koDuration = 0;
    player->transparentStatus = 0;
    player->transparentDuration = 0;
    player->isGlowing = FALSE;
    player->unk_21E = 0;
    player->disableDismissTimer = 0;
    player->attackBoost = 0;
    player->defenseBoost = 0;
    player->chillOutAmount = 0;
    player->chillOutTurns = 0;
    player->statusAfflicted = 0;
    player->actorTypeData1[0] = bActorSoundTable[player->actorType].walk[0];
    player->actorTypeData1[1] = bActorSoundTable[player->actorType].walk[1];
    player->actorTypeData1[2] = bActorSoundTable[player->actorType].fly[0];
    player->actorTypeData1[3] = bActorSoundTable[player->actorType].fly[1];
    player->actorTypeData1[4] = bActorSoundTable[player->actorType].jump;
    player->actorTypeData1[5] = bActorSoundTable[player->actorType].hurt;
    player->actorTypeData1b[0] = bActorSoundTable[player->actorType].delay[0];
    player->actorTypeData1b[1] = bActorSoundTable[player->actorType].delay[1];
 
    for (i = 0; i < ARRAY_COUNT(player->loopingSoundID); i++) {
        player->loopingSoundID[i] = 0;
    }
 
    part = heap_malloc(sizeof(*part));
    player->partsTable = part;
 
    ASSERT(part != NULL)
 
    player->numParts = 1;
    part->staticData = bMarioParts;
    part->partOffset.x = 0;
    part->partOffset.y = 0;
    part->partOffset.z = 0;
    part->partOffset.x = 12;
    part->partOffset.y = 32;
    part->partOffset.z = 5;
    part->decorationTable = NULL;
    part->flags = 0;
    part->targetFlags = 0;
    part->partOffsetFloat.x = 0.0f;
    part->partOffsetFloat.y = 0.0f;
    part->partOffsetFloat.z = 0.0f;
    part->rotPivotOffset.x = 0;
    part->rotPivotOffset.y = 0;
    part->rotPivotOffset.z = 0;
    part->visualOffset.x = 0;
    part->visualOffset.y = 0;
    part->visualOffset.z = 0;
    part->absolutePos.x = 0.0f;
    part->absolutePos.y = 0.0f;
    part->absolutePos.z = 0.0f;
    part->defenseTable = bMarioDefenseTable;
 
    if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
        part->idleAnimations = bPeachIdleAnims;
    } else {
        part->idleAnimations = bMarioIdleAnims;
    }
 
    part->eventFlags = 0;
    part->elementalImmunities = 0;
    part->opacity = 255;
    part->size.y = player->size.y;
    part->size.x = player->size.x;
    part->yaw = 0.0f;
    part->targetOffset.x = 0;
    part->targetOffset.y = 0;
    part->targetPriorityOffset = 0;
    part->rot.x = 0.0f;
    part->rot.y = 0.0f;
    part->rot.z = 0.0f;
    part->scale.x = 1.0f;
    part->scale.y = 1.0f;
    part->scale.z = 1.0f;
    part->verticalStretch = 1;
    part->palAnimPosOffset[0] = 0;
    part->palAnimPosOffset[1] = 0;
    part->animationRate = 1.0f;
    part->curAnimation = get_npc_anim_for_status(part->idleAnimations, 1U);
    part->nextPart = NULL;
    part->partTypeData[0] = bActorSoundTable[player->actorType].walk[0];
    part->partTypeData[1] = bActorSoundTable[player->actorType].walk[1];
    part->partTypeData[2] = bActorSoundTable[player->actorType].fly[0];
    part->partTypeData[3] = bActorSoundTable[player->actorType].fly[1];
    part->partTypeData[4] = bActorSoundTable[player->actorType].jump;
    part->partTypeData[5] = bActorSoundTable[player->actorType].hurt;
    part->actorTypeData2b[0] = bActorSoundTable[player->actorType].delay[0];
    part->actorTypeData2b[1] = bActorSoundTable[player->actorType].delay[1];
 
    if (part->idleAnimations != NULL) {
        s32 j;
 
        part->decorationTable = heap_malloc(sizeof(*decorations));
        decorations = part->decorationTable;
 
        ASSERT(decorations != NULL);
 
        decorations->paletteAdjustment = ACTOR_PAL_ADJUST_NONE;
        decorations->glowState = GLOW_PAL_OFF;
        decorations->flashState = 0;
        decorations->flashEnabled = FLASH_PAL_OFF;
        decorations->blurUnused = 0;
        decorations->blurBufferPos = 0;
 
        for (j = 0; j < ARRAY_COUNT(decorations->posX); j++) {
            decorations->posX[j] = player->curPos.x;
            decorations->posY[j] = player->curPos.y;
            decorations->posZ[j] = player->curPos.z;
        }
 
        decorations->blurDrawCount = 3;
        decorations->blurEnableCount = 0;
        decorations->blurDisableDelay = 0;
 
        for (j = 0; j < ARRAY_COUNT(decorations->effect); j++) {
            decorations->effect[j] = NULL;
            decorations->type[j] = 0;
        }
    }
 
    partMovement = part->movement = heap_malloc(sizeof(*partMovement));
    ASSERT(partMovement != NULL);
 
    player->shadow.id = create_shadow_type(SHADOW_VARYING_CIRCLE, player->curPos.x, player->curPos.y, player->curPos.z);
    player->shadowScale = player->size.x / 24.0;
    player->hudElementDataIndex = create_status_icon_set();
    player->disableEffect = fx_disable_x(0, -142.0f, 34.0f, 1.0f, 0);
    player->icePillarEffect = NULL;
 
    if (is_ability_active(ABILITY_ZAP_TAP)) {
        player->staticStatus = STATUS_KEY_STATIC;
        player->staticDuration = 127;
    }
}

Referenced by btl_state_update_normal_start().

◆ btl_state_update_normal_start()

void btl_state_update_normal_start ( void )

Definition at line 191 of file btl_states_actions.c.

                                         {
    BattleStatus* battleStatus = &gBattleStatus;
    EncounterStatus* currentEncounter = &gCurrentEncounter;
    Battle* battle;
    Stage* stage;
    s32 size;
    StatusBar* statusBar;
    void* compressedAsset;
    ModelNode* rootModel;
    s32 texturesOffset;
    Actor* actor;
    Evt* script;
    s32 enemyNotDone;
    s32 type;
    s32 i;
    s32 j;
 
    s32* types;
 
    battle = gCurrentBattlePtr;
    if (gOverrideBattlePtr != NULL) {
        battle = gOverrideBattlePtr;
    }
 
    if (gCurrentStagePtr == NULL) {
        stage = battle->stage;
    } else {
        stage = gCurrentStagePtr->stage;
    }
 
    battleStatus->curStage = stage;
    switch (gBattleSubState) {
        case BTL_SUBSTATE_NORMAL_START_INIT:
            #if DX_DEBUG_MENU
            dx_debug_set_battle_info(gCurrentBattleID << 16 | (gCurrentStageID & 0xFFFF), stage->shape);
            #endif
 
            BattleEnemiesCreated = battle->formationSize;
            set_screen_overlay_params_back(OVERLAY_NONE, -1.0f);
            compressedAsset = load_asset_by_name(stage->shape, &size);
            decode_yay0(compressedAsset, &gMapShapeData);
            general_heap_free(compressedAsset);
 
            ASSERT(size <= 0x8000);
 
            rootModel = gMapShapeData.header.root;
            texturesOffset = get_asset_offset(stage->texture, &size);
            if (rootModel != NULL) {
                load_data_for_models(rootModel, texturesOffset, size);
            }
            load_battle_hit_asset(stage->hit);
 
            if (stage->bg != NULL) {
                load_map_bg(stage->bg);
                set_background(&gBackgroundImage);
            }
 
            if (gGameStatusPtr->demoBattleFlags & DEMO_BTL_FLAG_ENABLED) {
                set_curtain_scale_goal(1.0f);
            }
 
            battleStatus->controlScript = NULL;
            battleStatus->camMovementScript = NULL;
            battleStatus->unk_90 = 0;
            battleStatus->preUpdateCallback = NULL;
            battleStatus->initBattleCallback = NULL;
            battleStatus->curSubmenu = 0;
            battleStatus->unk_49 = 0;
            battleStatus->curPartnerSubmenu = 0;
            battleStatus->unk_4B = 0;
            battleStatus->totalStarPoints = 0;
            battleStatus->pendingStarPoints = 0;
            battleStatus->incrementStarPointDelay = 0;
            battleStatus->damageTaken = 0;
            battleStatus->nextMerleeSpellType = MERLEE_SPELL_NONE;
            battleStatus->actionCommandMode = AC_MODE_NOT_LEARNED;
            gCameras[CAM_DEFAULT].flags |= CAMERA_FLAG_DISABLED;
            gCameras[CAM_BATTLE].flags |= CAMERA_FLAG_DISABLED;
            gCameras[CAM_TATTLE].flags |= CAMERA_FLAG_DISABLED;
            if (gPlayerData.hasActionCommands) {
                battleStatus->actionCommandMode = AC_MODE_LEARNED;
            }
            battleStatus->actionQuality = 0;
            battleStatus->maxActionQuality = 0;
            battleStatus->enabledMenusFlags = -1;
            battleStatus->enabledStarPowersFlags = -1;
            battleStatus->itemUsesLeft = 0;
            battleStatus->hammerCharge = 0;
            battleStatus->jumpCharge = 0;
            battleStatus->unk_98 = 0;
            battleStatus->hpDrainCount = 0;
            gBattleStatus.flags2 |= BS_FLAGS2_CAN_FLEE;
            if (currentEncounter->forbidFleeing) {
                gBattleStatus.flags2 &= ~BS_FLAGS2_CAN_FLEE;
            }
            battleStatus->endBattleFadeOutRate = 10;
            battleStatus->waitForState = BATTLE_STATE_0;
            battleStatus->hammerLossTurns = -1;
            battleStatus->jumpLossTurns = -1;
            battleStatus->itemLossTurns = -1;
            battleStatus->outtaSightActive = 0;
            battleStatus->waterBlockTurnsLeft = 0;
            battleStatus->waterBlockAmount = 0;
            battleStatus->waterBlockEffect = NULL;
            battleStatus->cloudNineTurnsLeft = 0;
            battleStatus->cloudNineDodgeChance = 0;
            battleStatus->cloudNineEffect = NULL;
            battleStatus->reflectFlags = 0;
            battleStatus->turboChargeTurnsLeft = 0;
            battleStatus->turboChargeAmount = 0;
            battleStatus->stateFreezeCount = 0;
            battleStatus->merleeAttackBoost = 0;
            battleStatus->merleeDefenseBoost = 0;
            battleStatus->darknessMode = BTL_DARKNESS_STATE_NONE;
            battleStatus->unk_433 = -1;
            battleStatus->hustleTurns = 0;
            battleStatus->unk_93 = 0;
            battleStatus->unk_94 = 0;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PARTNER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
            gBattleStatus.flags2 &= ~BS_FLAGS2_STORED_TURBO_CHARGE_TURN;
            gBattleStatus.flags2 &= ~BS_FLAGS2_DOING_JUMP_TUTORIAL;
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->varTable); i++) {
                battleStatus->varTable[i] = 0;
            }
 
            BattleScreenFadeAmt = 255;
            battleStatus->inputBitmask = 0xFFFFF & ~(BUTTON_START | 0xC0);
            battleStatus->buffEffect = fx_partner_buff(0, 0.0f, 0.0f, 0.0f, 0.0f, 0);
            setup_status_bar_for_battle();
            gCurrentCameraID = CAM_BATTLE;
            script = start_script(&EVS_OnBattleInit, EVT_PRIORITY_A, 0);
            battleStatus->camMovementScript = script;
            battleStatus->camMovementScriptID = script->id;
            gBattleSubState = BTL_SUBSTATE_NORMAL_START_CREATE_ENEMIES;
            break;
        case BTL_SUBSTATE_NORMAL_START_CREATE_ENEMIES:
            statusBar = &gStatusBar;
            if (does_script_exist(battleStatus->camMovementScriptID)) {
                break;
            }
 
            if (stage->preBattle != NULL) {
                script = start_script(stage->preBattle, EVT_PRIORITY_A, 0);
                battleStatus->controlScript = script;
                battleStatus->controlScriptID = script->id;
            }
 
            statusBar->hidden = FALSE;
            gBattleStatus.flags1 |= BS_FLAGS1_ACTORS_VISIBLE;
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                battleStatus->enemyActors[i] = NULL;
            }
            battleStatus->initialEnemyCount = 0;
 
            for (i = 0; i < BattleEnemiesCreated; i++) {
                create_actor(&(*battle->formation)[i]);
                types = bActorsIgnoreDuringCount;
                actor = battleStatus->enemyActors[i];
 
                while (TRUE) {
                    type = *types;
                    if (type == -1) {
                        battleStatus->initialEnemyCount++;
                        break;
                    } else if (actor->actorType == type) {
                        break;
                    }
                    types++;
                }
 
                actor->instigatorValue = 0;
                if (i == 0) {
                    actor->instigatorValue = currentEncounter->instigatorValue;
                    if (currentEncounter->dizzyAttack.status == STATUS_KEY_DIZZY) {
                        inflict_status_set_duration(actor, STATUS_KEY_DIZZY, STATUS_TURN_MOD_DIZZY, currentEncounter->dizzyAttack.duration);
                    }
                }
            }
 
            if (stage->stageEnemyCount != 0) {
                if (stage->stageEnemyChance == 0 || (stage->stageEnemyChance > 0 && (rand_int(stage->stageEnemyChance) == 0))) {
                    BattleEnemiesCreated += stage->stageEnemyCount;
                    for (j = 0; i < BattleEnemiesCreated; i++, j++) {
                        create_actor(&(*stage->stageFormation)[j]);
                        actor = battleStatus->enemyActors[i];
                        actor->instigatorValue = 0;
                        if (i == 0) {
                            actor->instigatorValue = 0;
                            if (currentEncounter->dizzyAttack.status == STATUS_KEY_DIZZY) {
                                inflict_status_set_duration(actor, STATUS_KEY_DIZZY, STATUS_TURN_MOD_DIZZY, currentEncounter->dizzyAttack.duration);
                            }
                        }
 
                    }
                }
            }
 
            load_player_actor();
            actor = battleStatus->playerActor;
            if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                script = start_script(&EVS_Peach_OnActorCreate, EVT_PRIORITY_A, 0);
            } else {
                script = start_script(&EVS_Mario_OnActorCreate, EVT_PRIORITY_A, 0);
            }
            actor->takeTurnScript = script;
            actor->takeTurnScriptID = script->id;
            script->owner1.actorID = ACTOR_PLAYER;
            load_partner_actor();
            gBattleSubState = BTL_SUBSTATE_NORMAL_START_CHECK_FIRST_STRIKE;
            break;
        case BTL_SUBSTATE_NORMAL_START_CHECK_FIRST_STRIKE:
            enemyNotDone = FALSE;
            for (i = 0; i < BattleEnemiesCreated; i++) {
                actor = battleStatus->enemyActors[i];
                if (does_script_exist(actor->takeTurnScriptID)) {
                    enemyNotDone = TRUE;
                    break;
                } else {
                    actor->takeTurnScript = NULL;
                }
            }
            if (enemyNotDone) {
                break;
            }
 
            actor = battleStatus->playerActor;
            if (does_script_exist(actor->takeTurnScriptID)) {
                break;
            }
            actor->takeTurnScript = NULL;
 
            actor = battleStatus->partnerActor;
            if (actor != NULL) {
                if (does_script_exist(actor->takeTurnScriptID)) {
                    break;
                }
                actor->takeTurnScript = NULL;
            }
 
            if (battle->onBattleStart != NULL) {
                script = start_script(battle->onBattleStart, EVT_PRIORITY_A, 0);
                battleStatus->controlScript = script;
                battleStatus->controlScriptID = script->id;
            }
            if (battleStatus->darknessMode > BTL_DARKNESS_STATE_NONE) {
                set_screen_overlay_color(SCREEN_LAYER_BACK, 0, 0, 0);
                set_screen_overlay_params_back(OVERLAY_SCREEN_COLOR, 215.0f);
            }
            if (is_ability_active(ABILITY_CHILL_OUT) && currentEncounter->firstStrikeType == FIRST_STRIKE_ENEMY) {
                currentEncounter->firstStrikeType = FIRST_STRIKE_NONE;
            }
 
            switch (currentEncounter->firstStrikeType) {
                case FIRST_STRIKE_PLAYER:
                    btl_set_state(BATTLE_STATE_FIRST_STRIKE);
                    break;
                case FIRST_STRIKE_ENEMY:
                    btl_set_state(BATTLE_STATE_ENEMY_FIRST_STRIKE);
                    break;
                default:
                    if (!(gGameStatusPtr->demoBattleFlags & DEMO_BTL_FLAG_ENABLED)) {
                        actor = battleStatus->playerActor;
                        if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                            script = start_script(&EVS_PeachEnterStage, EVT_PRIORITY_A, 0);
                        } else {
                            script = start_script(&EVS_MarioEnterStage, EVT_PRIORITY_A, 0);
                        }
                        actor->takeTurnScript = script;
                        actor->takeTurnScriptID = script->id;
                        script->owner1.actorID = ACTOR_PLAYER;
                    }
 
                    if (currentEncounter->curEnemy != NULL
                        && currentEncounter->curEnemy->encountered == ENCOUNTER_TRIGGER_SPIN
                        && is_ability_active(ABILITY_DIZZY_ATTACK)
                    ) {
                        actor = battleStatus->enemyActors[0];
                        script = start_script(&EVS_ApplyDizzyAttack, EVT_PRIORITY_A, 0);
                        actor->takeTurnScript = script;
                        actor->takeTurnScriptID = script->id;
                        script->owner1.enemyID = ACTOR_ENEMY0;
                    }
 
                    BattleScreenFadeAmt = 305;
                    BattleSubStateDelay = 0;
                    gBattleSubState = BTL_SUBSTATE_NORMAL_START_FADE_IN;
                    break;
            }
            break;
        case BTL_SUBSTATE_NORMAL_START_FADE_IN:
            if (BattleScreenFadeAmt == 0) {
                gBattleSubState = BTL_SUBSTATE_NORMAL_START_DONE;
                break;
            }
 
            BattleSubStateDelay++;
            if (BattleSubStateDelay == 15) {
                btl_cam_use_preset(BTL_CAM_DEFAULT);
            }
 
            if (!(gGameStatusPtr->demoBattleFlags & DEMO_BTL_FLAG_ENABLED)) {
                BattleScreenFadeAmt -= 10;
            } else {
                BattleScreenFadeAmt -= 50;
            }
 
            if (BattleScreenFadeAmt < 0) {
                BattleScreenFadeAmt = 0;
            }
            break;
        case BTL_SUBSTATE_NORMAL_START_DONE:
            if (battleStatus->stateFreezeCount == 0) {
                set_screen_overlay_params_front(OVERLAY_NONE, -1.0f);
                btl_set_state(BATTLE_STATE_BEGIN_TURN);
            }
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_normal_start()

void btl_state_draw_normal_start ( void )

Definition at line 515 of file btl_states_actions.c.

                                       {
    set_screen_overlay_color(SCREEN_LAYER_FRONT, 0, 0, 0);
 
    if (BattleScreenFadeAmt > 255) {
        set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, 255.0f);
    } else {
        set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, BattleScreenFadeAmt);
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_begin_turn()

void btl_state_update_begin_turn ( void )

Definition at line 525 of file btl_states_actions.c.

                                       {
    BattleStatus* battleStatus = &gBattleStatus;
    PlayerData* playerData = &gPlayerData;
    Actor* partner = battleStatus->partnerActor;
    Actor* player = battleStatus->playerActor;
    Actor* enemy;
    Actor* enemy1;
    Actor* enemy2;
    Evt* script;
    Evt* script2;
    s32 cond;
    u16 id1;
    u16 id2;
    s32 numEnemyActors;
    s32 i;
    s32 j;
    s16* enemyIDs;
 
    if (gBattleSubState == BTL_SUBSTATE_BEGIN_TURN_INIT) {
        battleStatus->flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
        battleStatus->flags2 &= ~BS_FLAGS2_PARTNER_TURN_USED;
        battleStatus->flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
        battleStatus->flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
        battleStatus->merleeAttackBoost = 0;
        battleStatus->merleeDefenseBoost = 0;
        battleStatus->flags2 &= ~BS_FLAGS2_IS_FIRST_STRIKE;
 
        player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
        player->disableDismissTimer = 0;
        if (partner != NULL) {
            player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
            partner->disableDismissTimer = 0;
        }
 
        if (battleStatus->hustleTurns != 0) {
            gBattleStatus.flags1 |= BS_FLAGS1_HUSTLED;
        }
 
        numEnemyActors = 0;
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            enemy = battleStatus->enemyActors[i];
            if (enemy != NULL) {
                battleStatus->enemyIDs[numEnemyActors] = i | ACTOR_ENEMY0;
                numEnemyActors++;
            }
        }
        battleStatus->numEnemyActors = numEnemyActors;
 
        // sort enemies by x-position or turn priority
        enemyIDs = battleStatus->enemyIDs;
        for (i = 0; i < numEnemyActors - 1; i++) {
            for (j = i + 1; j < numEnemyActors; j++) {
                id1 = enemyIDs[i];
                id2 = enemyIDs[j];
                enemy1 = battleStatus->enemyActors[id1 & 0xFF];
                enemy2 = battleStatus->enemyActors[id2 & 0xFF];
                if (gBattleStatus.flags1 & BS_FLAGS1_SORT_ENEMIES_BY_POSX) {
                    if (enemy1->homePos.x > enemy2->homePos.x) {
                        enemyIDs[i] = id2;
                        enemyIDs[j] = id1;
                    }
                } else if (enemy1->turnPriority < enemy2->turnPriority) {
                    enemyIDs[i] = id2;
                    enemyIDs[j] = id1;
                }
            }
        }
        battleStatus->nextEnemyIndex = 0;
 
        btl_merlee_on_start_turn();
 
        // clear rush flags to initialize
        battleStatus->rushFlags = RUSH_FLAG_NONE;
        gBattleStatus.flags2 &= ~BS_FLAGS2_HAS_RUSH;
 
        // set rush flags based on danger/peril status
        if (!(gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE)) {
            if (playerData->curHP <= PERIL_THRESHOLD && is_ability_active(ABILITY_MEGA_RUSH)) {
                gBattleStatus.flags2 |= BS_FLAGS2_HAS_RUSH;
                battleStatus->rushFlags |= RUSH_FLAG_MEGA;
            }
            if (playerData->curHP <= DANGER_THRESHOLD && is_ability_active(ABILITY_POWER_RUSH)) {
                if (!(battleStatus->rushFlags & RUSH_FLAG_MEGA)) {
                    gBattleStatus.flags2 |= BS_FLAGS2_HAS_RUSH;
                    battleStatus->rushFlags |= RUSH_FLAG_POWER;
                }
            }
        }
 
        if (!(gBattleStatus.flags1 & BS_FLAGS1_JUMP_CHARGED)) {
            battleStatus->jumpCharge = 0;
        }
 
        if (!(gBattleStatus.flags1 & BS_FLAGS1_HAMMER_CHARGED)) {
            battleStatus->hammerCharge = 0;
        }
 
        if (gGameStatusPtr->debugEnemyContact == DEBUG_CONTACT_AUTO_FLEE) {
            btl_set_state(BATTLE_STATE_RUN_AWAY);
            return;
        }
 
        if (gGameStatusPtr->debugEnemyContact == DEBUG_CONTACT_DIE_IN_BATTLE) {
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL && enemy->handleEventSource != NULL) {
                    Evt* script = start_script(enemy->handleEventSource, EVT_PRIORITY_A, 0);
 
                    enemy->handleEventScript = script;
                    script->owner1.actorID = i | ACTOR_ENEMY0;
                    enemy->handleEventScriptID = script->id;
                    enemy->lastEventType = EVENT_DEATH;
                }
            }
            gBattleSubState = BTL_SUBSTATE_BEGIN_TURN_AWAIT_ENEMY_DEATH;
        } else {
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL && enemy->handlePhaseSource != NULL) {
                    battleStatus->battlePhase = PHASE_PLAYER_BEGIN;
                    script = start_script(enemy->handlePhaseSource, EVT_PRIORITY_A, 0);
                    enemy->handlePhaseScript = script;
                    enemy->handleBatttlePhaseScriptID = script->id;
                    script->owner1.actorID = i | ACTOR_ENEMY0;
                }
            }
 
            partner = battleStatus->partnerActor;
            if (partner != NULL) {
                if (partner->handlePhaseSource != NULL) {
                    battleStatus->battlePhase = PHASE_PLAYER_BEGIN;
                    script = start_script(partner->handlePhaseSource, EVT_PRIORITY_A, 0);
                    partner->handlePhaseScript = script;
                    partner->handleBatttlePhaseScriptID = script->id;
                    script->owner1.actorID = ACTOR_PARTNER;
                }
            }
            gBattleSubState = BTL_SUBSTATE_BEGIN_TURN_AWAIT_ENEMY_SCRIPTS;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_BEGIN_TURN_AWAIT_ENEMY_SCRIPTS) {
        cond = FALSE;
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            enemy = battleStatus->enemyActors[i];
            if (enemy != NULL && enemy->handlePhaseSource != NULL && does_script_exist(enemy->handleBatttlePhaseScriptID)) {
                cond = TRUE;
            }
        }
        if (partner != NULL && partner->handlePhaseSource != NULL && does_script_exist(partner->handleBatttlePhaseScriptID)) {
            cond = TRUE;
        }
 
        if (!cond) {
            if (!btl_check_enemies_defeated()) {
                btl_set_state(BATTLE_STATE_BEGIN_PLAYER_TURN);
            }
            return;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_BEGIN_TURN_AWAIT_ENEMY_DEATH) {
        cond = FALSE;
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            enemy = battleStatus->enemyActors[i];
            if (enemy != NULL && enemy->handleEventSource != NULL && does_script_exist(enemy->handleEventScriptID)) {
                cond = TRUE;
            }
        }
 
        if (!cond) {
            if (!btl_check_enemies_defeated()) {
                btl_set_state(BATTLE_STATE_BEGIN_PLAYER_TURN);
            }
        }
    }
}

Referenced by btl_update().

◆ btl_state_draw_begin_turn()

void btl_state_draw_begin_turn ( void )

Definition at line 703 of file btl_states_actions.c.

703 {

704}

Referenced by btl_draw_ui().

◆ btl_state_update_begin_player_turn()

void btl_state_update_begin_player_turn ( void )

Definition at line 706 of file btl_states_actions.c.

                                              {
    BattleStatus* battleStatus = &gBattleStatus;
    PlayerData* playerData = &gPlayerData;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    ActorPart* part = &player->partsTable[0];
    Evt* script;
    s32 i;
 
    s8 debuffDuration;
    s32 koDuration;
    s32 temp;
 
    if (gBattleSubState == BTL_SUBSTATE_BEGIN_PLAYER_TURN_INIT) {
        btl_cam_use_preset(BTL_CAM_DEFAULT);
        btl_cam_move(5);
        gBattleSubState = BTL_SUBSTATE_BEGIN_PLAYER_TURN_RESET_STATE;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_BEGIN_PLAYER_TURN_RESET_STATE:
            if (btl_cam_is_moving_done()) {
                gBattleStatus.flags1 &= ~BS_FLAGS1_PARTNER_ACTING;
                reset_actor_turn_info();
                battleStatus->actionResult = ACTION_RESULT_NONE;
                battleStatus->blockResult = BLOCK_RESULT_NONE;
                battleStatus->selectedMoveID = 0;
                gBattleStatus.flags1 |= BS_FLAGS1_SHOW_PLAYER_DECORATIONS;
                gBattleStatus.flags2 &= ~BS_FLAGS2_IS_FIRST_STRIKE;
                player->disableDismissTimer = 0;
                player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
 
                if (partner != NULL) {
                    player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
                    partner->disableDismissTimer = 0;
                }
 
                battleStatus->stateFreezeCount = 0;
                D_8029F254 = FALSE;
                D_8029F258 = 0;
 
                if (battleStatus->outtaSightActive == 0) {
                    gBattleSubState = BTL_SUBSTATE_BEGIN_PLAYER_TURN_CHECK_WATER_BLOCK;
                } else {
                    battleStatus->battlePhase = PHASE_ENEMY_BEGIN;
                    script = start_script(partner->handlePhaseSource, EVT_PRIORITY_A, 0);
                    partner->handlePhaseScript = script;
                    gBattleSubState = BTL_SUBSTATE_BEGIN_PLAYER_TURN_AWAIT_OUTTA_SIGHT;
                    partner->handleBatttlePhaseScriptID = script->id;
                    script->owner1.actorID = ACTOR_PARTNER;
                }
            }
            break;
        case BTL_SUBSTATE_BEGIN_PLAYER_TURN_AWAIT_OUTTA_SIGHT:
            if (!does_script_exist(partner->handleBatttlePhaseScriptID)) {
                battleStatus->outtaSightActive = 0;
                gBattleSubState = BTL_SUBSTATE_BEGIN_PLAYER_TURN_CHECK_WATER_BLOCK;
                gBattleStatus.flags2 |= BS_FLAGS2_PARTNER_TURN_USED;
            }
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_BEGIN_PLAYER_TURN_CHECK_WATER_BLOCK:
            if (battleStatus->stateFreezeCount == 0) {
                if (battleStatus->waterBlockTurnsLeft != 0) {
                    battleStatus->waterBlockTurnsLeft--;
                    battleStatus->buffEffect->data.partnerBuff->unk_0C[FX_BUFF_DATA_WATER_BLOCK].turnsLeft = battleStatus->waterBlockTurnsLeft;
                    if (battleStatus->waterBlockTurnsLeft <= 0) {
                        battleStatus->waterBlockEffect->flags |= FX_INSTANCE_FLAG_DISMISS;
                        fx_water_block(FX_WATER_BLOCK_DESTROY, player->curPos.x, player->curPos.y + 18.0f, player->curPos.z + 5.0f, 1.5f, 10);
                        fx_water_splash(0, player->curPos.x - 10.0f, player->curPos.y + 5.0f, player->curPos.z + 5.0f, 1.0f, 24);
                        fx_water_splash(0, player->curPos.x - 15.0f, player->curPos.y + 32.0f, player->curPos.z + 5.0f, 1.0f, 24);
                        fx_water_splash(1, player->curPos.x + 15.0f, player->curPos.y + 22.0f, player->curPos.z + 5.0f, 1.0f, 24);
                        battleStatus->waterBlockEffect = NULL;
                        sfx_play_sound(SOUND_DESTROY_WATER_BLOCK);
                        btl_show_battle_message(BTL_MSG_WATER_BLOCK_END, 60);
                        gBattleSubState = BTL_SUBSTATE_BEGIN_PLAYER_TURN_AWAIT_WATER_BLOCK;
                    } else {
                        gBattleSubState = BTL_SUBSTATE_BEGIN_PLAYER_TURN_CHECK_CLOUD_NINE;
                    }
                } else {
                    gBattleSubState = BTL_SUBSTATE_BEGIN_PLAYER_TURN_CHECK_CLOUD_NINE;
                }
            }
            break;
        case BTL_SUBSTATE_BEGIN_PLAYER_TURN_AWAIT_WATER_BLOCK:
            if (!btl_is_popup_displayed()) {
                gBattleSubState = BTL_SUBSTATE_BEGIN_PLAYER_TURN_CHECK_CLOUD_NINE;
            }
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_BEGIN_PLAYER_TURN_CHECK_CLOUD_NINE:
            if (battleStatus->cloudNineTurnsLeft != 0) {
                battleStatus->cloudNineTurnsLeft--;
                battleStatus->buffEffect->data.partnerBuff->unk_0C[FX_BUFF_DATA_CLOUD_NINE].turnsLeft = battleStatus->cloudNineTurnsLeft;
 
                if (battleStatus->cloudNineTurnsLeft <= 0) {
                    remove_effect(battleStatus->cloudNineEffect);
                    battleStatus->cloudNineEffect = NULL;
                    btl_show_battle_message(BTL_MSG_CLOUD_NINE_END, 60);
                    gBattleSubState = BTL_SUBSTATE_BEGIN_PLAYER_TURN_AWAIT_CLOUD_NINE;
                } else {
                    gBattleSubState = BTL_SUBSTATE_BEGIN_PLAYER_TURN_CHECK_TURBO_CHARGE;
                }
            } else {
                gBattleSubState = BTL_SUBSTATE_BEGIN_PLAYER_TURN_CHECK_TURBO_CHARGE;
            }
            break;
        case BTL_SUBSTATE_BEGIN_PLAYER_TURN_AWAIT_CLOUD_NINE:
            if (!btl_is_popup_displayed()) {
                gBattleSubState = BTL_SUBSTATE_BEGIN_PLAYER_TURN_CHECK_TURBO_CHARGE;
            }
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_BEGIN_PLAYER_TURN_CHECK_TURBO_CHARGE:
            if (battleStatus->turboChargeTurnsLeft != 0) {
                if (gBattleStatus.flags2 & BS_FLAGS2_STORED_TURBO_CHARGE_TURN) {
                    gBattleStatus.flags2 &= ~BS_FLAGS2_STORED_TURBO_CHARGE_TURN;
                    gBattleSubState = BTL_SUBSTATE_BEGIN_PLAYER_TURN_TRY_STATUS_DAMAGE;
                } else {
                    battleStatus->turboChargeTurnsLeft--;
                    battleStatus->buffEffect->data.partnerBuff->unk_0C[FX_BUFF_DATA_TURBO_CHARGE].turnsLeft = battleStatus->turboChargeTurnsLeft;
                    if (battleStatus->turboChargeTurnsLeft <= 0) {
                        btl_show_battle_message(BTL_MSG_TURBO_CHARGE_END, 60);
                        gBattleSubState = BTL_SUBSTATE_BEGIN_PLAYER_TURN_AWAIT_TURBO_CHARGE;
                    } else {
                        gBattleSubState = BTL_SUBSTATE_BEGIN_PLAYER_TURN_TRY_STATUS_DAMAGE;
                    }
                }
            } else {
                gBattleSubState = BTL_SUBSTATE_BEGIN_PLAYER_TURN_TRY_STATUS_DAMAGE;
            }
            break;
        case BTL_SUBSTATE_BEGIN_PLAYER_TURN_AWAIT_TURBO_CHARGE:
            if (!btl_is_popup_displayed()) {
                gBattleSubState = BTL_SUBSTATE_BEGIN_PLAYER_TURN_TRY_STATUS_DAMAGE;
            }
            break;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_BEGIN_PLAYER_TURN_TRY_STATUS_DAMAGE) {
        if (player->debuff == STATUS_KEY_POISON && player->stoneStatus == 0) {
            gBattleStatus.flags1 |= BS_FLAGS1_TRIGGER_EVENTS;
            dispatch_damage_tick_event_player(1, EVENT_HIT);
        }
 
        // clear rush flags to initialize
        battleStatus->rushFlags = RUSH_FLAG_NONE;
        gBattleStatus.flags2 &= ~BS_FLAGS2_HAS_RUSH;
 
        // set rush flags based on danger/peril status
        if (!(gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE)) {
            if (playerData->curHP <= PERIL_THRESHOLD && is_ability_active(ABILITY_MEGA_RUSH)) {
                gBattleStatus.flags2 |= BS_FLAGS2_HAS_RUSH;
                battleStatus->rushFlags |= RUSH_FLAG_MEGA;
            }
            if (playerData->curHP <= DANGER_THRESHOLD && is_ability_active(ABILITY_POWER_RUSH)) {
                if (!(battleStatus->rushFlags & RUSH_FLAG_MEGA)) {
                    gBattleStatus.flags2 |= BS_FLAGS2_HAS_RUSH;
                    battleStatus->rushFlags |= RUSH_FLAG_POWER;
                }
            }
        }
        gBattleSubState = BTL_SUBSTATE_BEGIN_PLAYER_TURN_TRY_STATUS_RECOVER;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_BEGIN_PLAYER_TURN_TRY_STATUS_RECOVER) {
        if (player->handleEventScript == NULL || !does_script_exist(player->handleEventScriptID)) {
            player->handleEventScript = NULL;
            if (btl_check_player_defeated()) {
                return;
            }
 
            D_8029F254 = FALSE;
            player->disableDismissTimer = 0;
            player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
 
            if (is_ability_active(ABILITY_FEELING_FINE)) {
                if (player->debuff != 0) {
                    player->debuffDuration = 1;
                }
                if (player->staticStatus != 0) {
                    player->staticDuration = 1;
                }
                if (player->stoneStatus != 0) {
                    player->stoneDuration = 1;
                }
                if (player->koStatus != 0) {
                    player->koDuration = 1;
                }
                if (player->transparentStatus != 0) {
                    player->transparentDuration = 1;
                }
            }
 
            if (player->stoneStatus != 0) {
                player->stoneDuration--;
                if (player->stoneDuration <= 0) {
                    player->stoneStatus = 0;
                    dispatch_event_player(EVENT_RECOVER_STATUS);
                }
            } else {
                if (!is_ability_active(ABILITY_ZAP_TAP) && player->staticStatus != 0) {
                    player->staticDuration--;
                    if (player->staticDuration <= 0) {
                        player->staticStatus = 0;
                        remove_status_static(player->hudElementDataIndex);
                    }
                }
                if (player->transparentStatus != 0) {
                    player->transparentDuration--;
                    part->flags |= ACTOR_PART_FLAG_TRANSPARENT;
                    if (player->transparentDuration <= 0) {
                        player->transparentStatus = 0;
                        part->flags &= ~ACTOR_PART_FLAG_TRANSPARENT;
                        remove_status_transparent(player->hudElementDataIndex);
                    }
                }
 
                if (player->debuff != 0) {
                    if (player->debuff < 9) {
                        D_8029F254 = TRUE;
                    }
                    D_8029F258 = 20;
                    player->debuffDuration--;
                    if (player->debuffDuration <= 0) {
                        if (player->debuff == STATUS_KEY_FROZEN) {
                            sfx_play_sound(SOUND_FROZEN_SHATTER);
                            player->icePillarEffect->flags |= FX_INSTANCE_FLAG_DISMISS;
                            player->icePillarEffect = NULL;
                            dispatch_event_player(EVENT_32);
                        } else {
                            dispatch_event_player(EVENT_RECOVER_STATUS);
                        }
                        player->debuff = 0;
                        player->debuffDuration = 0;
                        remove_status_debuff(player->hudElementDataIndex);
                    }
                }
 
                debuffDuration = player->debuffDuration;
                temp = player->koDuration;
                player->koDuration = debuffDuration;
                if (debuffDuration > 0) {
                    player->koStatus = STATUS_KEY_DAZE;
                    player->disableEffect->data.disableX->koDuration = player->koDuration;
                } else if (temp != debuffDuration) {
                    player->koStatus = 0;
                    player->koDuration = 0;
                    player->disableEffect->data.disableX->koDuration = 0;
                }
            }
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                Actor* enemy = battleStatus->enemyActors[i];
 
                if (enemy != NULL) {
                    enemy->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
                    if (enemy->chillOutTurns != 0) {
                        enemy->chillOutTurns--;
                        if (enemy->chillOutTurns == 0) {
                            enemy->chillOutAmount = 0;
                            remove_status_chill_out(enemy->hudElementDataIndex);
                            D_8029F258 = 20;
                        }
                    }
                }
            }
            gBattleSubState = BTL_SUBSTATE_BEGIN_PLAYER_TURN_TRY_COMMAND_RECOVER;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_BEGIN_PLAYER_TURN_TRY_COMMAND_RECOVER) {
        if (btl_check_enemies_defeated()) {
            return;
        }
        temp = 1;
        battleStatus->stateFreezeCount = 0;
        if (battleStatus->hammerLossTurns >= 0) {
            battleStatus->hammerLossTurns--;
            if (battleStatus->hammerLossTurns == -1) {
                script = start_script(&EVS_PlayerRegainAbility, EVT_PRIORITY_A, 0);
                player->takeTurnScript = script;
                player->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PLAYER;
                script->varTable[0] = temp;
                temp += 8; // temp here should be named itemSpawnOffsetX
                script->varTable[10] = BTL_MENU_TYPE_SMASH;
                battleStatus->stateFreezeCount = 1;
            }
        }
 
        if (battleStatus->jumpLossTurns >= 0) {
            battleStatus->jumpLossTurns--;
            if (battleStatus->jumpLossTurns == -1) {
                script = start_script(&EVS_PlayerRegainAbility, EVT_PRIORITY_A, 0);
                player->takeTurnScript = script;
                player->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PLAYER;
                script->varTable[0] = temp;
                temp += 8;
                script->varTable[10] = BTL_MENU_TYPE_JUMP;
                battleStatus->stateFreezeCount = 1;
            }
        }
 
        if (battleStatus->itemLossTurns >= 0) {
            battleStatus->itemLossTurns--;
            if (battleStatus->itemLossTurns == -1) {
                script = start_script(&EVS_PlayerRegainAbility, EVT_PRIORITY_A, 0);
                player->takeTurnScript = script;
                player->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PLAYER;
                script->varTable[0] = temp;
                temp += 8;
                script->varTable[10] = BTL_MENU_TYPE_ITEMS;
                battleStatus->stateFreezeCount = 1;
            }
        }
        gBattleSubState = BTL_SUBSTATE_BEGIN_PLAYER_TURN_END_DELAY;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_BEGIN_PLAYER_TURN_END_DELAY) {
        if (player->handleEventScript == NULL || !does_script_exist(player->handleEventScriptID)) {
            player->handleEventScript = NULL;
 
            if (btl_check_player_defeated() || btl_check_enemies_defeated()) {
                return;
            }
 
            if (D_8029F258 != 0) {
                D_8029F258--;
                return;
            }
 
            if (!D_8029F254) {
                btl_set_state(BATTLE_STATE_SWITCH_TO_PLAYER);
            } else{
                btl_set_state(BATTLE_STATE_BEGIN_PARTNER_TURN);
                gBattleStatus.flags2 |= BS_FLAGS2_PLAYER_TURN_USED;
            }
        }
    }
}

Referenced by btl_update().

◆ btl_state_draw_begin_player_turn()

void btl_state_draw_begin_player_turn ( void )

Definition at line 1056 of file btl_states_actions.c.

1056 {

1057}

Referenced by btl_draw_ui().

◆ btl_state_update_switch_to_player()

void btl_state_update_switch_to_player ( void )

Definition at line 1059 of file btl_states_actions.c.

                                             {
    Actor* player = gBattleStatus.playerActor;
    Actor* partner = gBattleStatus.partnerActor;
    s32 i;
 
    if (gBattleSubState == BTL_SUBSTATE_INIT) {
        gBattleStatus.flags1 &= ~BS_FLAGS1_PARTNER_ACTING;
        reset_actor_turn_info();
        gBattleStatus.selectedMoveID = MOVE_NONE;
        gBattleStatus.actionResult = ACTION_RESULT_NONE;
        gBattleStatus.blockResult = BLOCK_RESULT_NONE;
        gBattleStatus.flags1 |= BS_FLAGS1_SHOW_PLAYER_DECORATIONS;
        player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
        if (partner != NULL) {
            partner->flags |= (ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM);
        }
 
        for (i = 0; i < ARRAY_COUNT(gBattleStatus.enemyActors); i++) {
            Actor* enemy = gBattleStatus.enemyActors[i];
 
            if (enemy != NULL) {
                enemy->flags |= ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                enemy->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            }
        }
 
        btl_set_state(BATTLE_STATE_PREPARE_MENU);
    }
}

Referenced by btl_update().

◆ btl_state_draw_switch_to_player()

void btl_state_draw_switch_to_player ( void )

Definition at line 1089 of file btl_states_actions.c.

1089 {

1090}

Referenced by btl_draw_ui().

◆ btl_state_update_begin_partner_turn()

void btl_state_update_begin_partner_turn ( void )

Definition at line 1092 of file btl_states_actions.c.

                                               {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* partner = battleStatus->partnerActor;
    Actor* enemy;
    Evt* script;
    s32 i;
 
    if (gBattleSubState == BTL_SUBSTATE_BEGIN_PARTNER_TURN_INIT) {
        if (partner == NULL) {
            D_8029F254 = TRUE;
            gBattleSubState = BTL_SUBSTATE_BEGIN_PARTNER_TURN_END_DELAY;
        } else if ((battleStatus->flags2 & (BS_FLAGS2_PARTNER_TURN_USED | BS_FLAGS2_PLAYER_TURN_USED)) != (BS_FLAGS2_PARTNER_TURN_USED | BS_FLAGS2_PLAYER_TURN_USED)) {
            if (!(partner->flags & ACTOR_FLAG_NO_ATTACK)) {
                btl_cam_use_preset(BTL_CAM_DEFAULT);
                btl_cam_move(5);
                gBattleSubState = BTL_SUBSTATE_BEGIN_PARTNER_TURN_RESET_STATE;
            } else {
                btl_set_state(BATTLE_STATE_9);
                return;
            }
        } else {
            btl_set_state(BATTLE_STATE_9);
            return;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_BEGIN_PARTNER_TURN_RESET_STATE) {
        if (btl_cam_is_moving_done()) {
            D_8029F258 = 0;
            reset_actor_turn_info();
            partner = battleStatus->partnerActor;
            battleStatus->actionResult = ACTION_RESULT_NONE;
            battleStatus->blockResult = BLOCK_RESULT_NONE;
            D_8029F254 = FALSE;
            gBattleStatus.flags1 |= BS_FLAGS1_PARTNER_ACTING;
            gBattleStatus.flags2 |= BS_FLAGS1_PLAYER_IN_BACK;
            partner->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
 
            if (partner->koStatus != 0) {
                partner->koDuration--;
                D_8029F254 = TRUE;
                D_8029F258 = 20;
                if (partner->koDuration > 0) {
                    partner->disableEffect->data.disableX->koDuration = partner->koDuration;
                } else {
                    partner->koStatus = 0;
                    dispatch_event_partner(EVENT_RECOVER_FROM_KO);
                    partner->disableEffect->data.disableX->koDuration = 0;
                    gBattleStatus.flags2 |= BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
                }
            }
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL) {
                    enemy->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
                }
            }
            gBattleSubState = BTL_SUBSTATE_BEGIN_PARTNER_TURN_AWAIT_RECOVER_DONE;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_BEGIN_PARTNER_TURN_AWAIT_RECOVER_DONE) {
        if (partner != NULL) {
            if (partner->handleEventScript != NULL && does_script_exist(partner->handleEventScriptID)) {
                goto WAITING;
            }
            partner->handleEventScript = NULL;
        }
 
        gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
        if (btl_check_player_defeated() || btl_check_enemies_defeated()) {
            return;
        }
        gBattleSubState = BTL_SUBSTATE_BEGIN_PARTNER_TURN_EXEC_TURN_SCRIPT;
    }
    WAITING:
 
    if (gBattleSubState == BTL_SUBSTATE_BEGIN_PARTNER_TURN_EXEC_TURN_SCRIPT) {
        if (partner->handlePhaseSource != NULL) {
            battleStatus->battlePhase = PHASE_ENEMY_BEGIN;
            script = start_script(partner->handlePhaseSource, EVT_PRIORITY_A, 0);
            partner->handlePhaseScript = script;
            partner->handleBatttlePhaseScriptID = script->id;
            script->owner1.actorID = ACTOR_PARTNER;
        }
        gBattleSubState = BTL_SUBSTATE_BEGIN_PARTNER_TURN_AWAIT_TURN_SCRIPT;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_BEGIN_PARTNER_TURN_AWAIT_TURN_SCRIPT) {
        if (partner->handlePhaseSource == NULL || !does_script_exist(partner->handleBatttlePhaseScriptID)) {
            gBattleSubState = BTL_SUBSTATE_BEGIN_PARTNER_TURN_END_DELAY;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_BEGIN_PARTNER_TURN_END_DELAY) {
        if (D_8029F258 != 0) {
            D_8029F258--;
            return;
        }
        gBattleStatus.flags2 &= ~BS_FLAGS2_NO_PLAYER_PAL_ADJUST;
        if (!D_8029F254) {
            btl_set_state(BATTLE_STATE_SWITCH_TO_PARTNER);
        } else {
            gBattleStatus.flags2 |= BS_FLAGS2_PARTNER_TURN_USED;
            btl_set_state(BATTLE_STATE_9);
        }
    }
}

Referenced by btl_update().

◆ btl_state_draw_begin_partner_turn()

void btl_state_draw_begin_partner_turn ( void )

Definition at line 1202 of file btl_states_actions.c.

1202 {

1203}

Referenced by btl_draw_ui().

◆ btl_state_update_switch_to_partner()

void btl_state_update_switch_to_partner ( void )

Definition at line 1205 of file btl_states_actions.c.

                                              {
    Actor* player = gBattleStatus.playerActor;
    Actor* partner = gBattleStatus.partnerActor;
    s32 i;
 
    if (gBattleSubState == BTL_SUBSTATE_INIT) {
        reset_actor_turn_info();
        gBattleStatus.flags1 |= BS_FLAGS1_PARTNER_ACTING;
        gBattleStatus.selectedMoveID = MOVE_NONE;
        gBattleStatus.actionResult = ACTION_RESULT_NONE;
        gBattleStatus.blockResult = BLOCK_RESULT_NONE;
        gBattleStatus.flags1 |= BS_FLAGS1_SHOW_PLAYER_DECORATIONS;
        player->flags |= (ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM);
        partner->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
 
        for (i = 0; i < ARRAY_COUNT(gBattleStatus.enemyActors); i++) {
            Actor* enemy = gBattleStatus.enemyActors[i];
            if (enemy != NULL) {
                enemy->flags |= ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                enemy->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            }
        }
 
        btl_set_state(BATTLE_STATE_PREPARE_MENU);
    }
}

Referenced by btl_update().

◆ btl_state_draw_switch_to_partner()

void btl_state_draw_switch_to_partner ( void )

Definition at line 1232 of file btl_states_actions.c.

1232 {

1233}

Referenced by btl_draw_ui().

◆ btl_state_update_9()

void btl_state_update_9 ( void )

Definition at line 1235 of file btl_states_actions.c.

                              {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    Actor* actor;
    ActorState* state;
    Evt* script;
    s32 waitingForScript;
    s32 i;
 
    s32 oldKoDuration;
 
    if (gBattleSubState == BTL_SUBSTATE_9_INIT) {
        if (!(gBattleStatus.flags2 & BS_FLAGS2_PLAYER_TURN_USED)) {
            btl_set_state(BATTLE_STATE_SWITCH_TO_PLAYER);
            return;
        }
 
        if (partner != NULL) {
            if (!(gBattleStatus.flags2 & BS_FLAGS2_PARTNER_TURN_USED) && !(partner->flags & ACTOR_FLAG_NO_ATTACK)) {
                btl_set_state(BATTLE_STATE_SWITCH_TO_PARTNER);
                return;
            }
        }
 
        player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
        player->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
        if (partner != NULL) {
            partner->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            partner->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
        }
 
        gBattleSubState = BTL_SUBSTATE_9_1;
        D_8029F258 = 0;
        gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
        gBattleStatus.flags2 &= ~BS_FLAGS2_PARTNER_TURN_USED;
        gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
        gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_9_1) {
        waitingForScript = FALSE;
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            actor = battleStatus->enemyActors[i];
            if (actor != NULL && actor->handleEventScript != NULL) {
                if (does_script_exist(actor->handleEventScriptID)) {
                    waitingForScript = TRUE;
                } else {
                    actor->handleEventScript = NULL;
                }
            }
        }
 
        if (!waitingForScript) {
            reset_actor_turn_info();
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL) {
                    actor->flags |= ACTOR_FLAG_USING_IDLE_ANIM | ACTOR_FLAG_SHOW_STATUS_ICONS;
                    actor->flags &= ~ACTOR_FLAG_SKIP_TURN;
 
                    if (actor->debuff != 0) {
                        if (actor->debuff == STATUS_KEY_FEAR
                            || actor->debuff == STATUS_KEY_DIZZY
                            || actor->debuff == STATUS_KEY_PARALYZE
                            || actor->debuff == STATUS_KEY_SLEEP
                            || actor->debuff == STATUS_KEY_FROZEN
                            || actor->debuff == STATUS_KEY_STOP
                        ) {
                            actor->flags |= ACTOR_FLAG_SKIP_TURN;
                        }
                        actor->debuffDuration--;
                        if (actor->debuffDuration <= 0) {
                            actor->debuff = 0;
                            remove_status_debuff(actor->hudElementDataIndex);
                            dispatch_event_actor(actor, EVENT_RECOVER_STATUS);
                            D_8029F258 = 20;
                        }
                    }
 
                    if (actor->staticStatus != 0) {
                        actor->staticDuration--;
                        if (actor->staticDuration <= 0) {
                            actor->staticStatus = 0;
                            remove_status_static(actor->hudElementDataIndex);
                            D_8029F258 = 20;
                        }
                    }
 
                    if (actor->transparentStatus != 0) {
                        actor->transparentDuration--;
                        if (actor->transparentDuration <= 0) {
                            actor->transparentStatus = 0;
                            remove_status_transparent(actor->hudElementDataIndex);
                            D_8029F258 = 20;
                        }
                    }
 
                    if (actor->stoneStatus != 0) {
                        actor->stoneDuration--;
                        if (actor->stoneDuration <= 0) {
                            actor->stoneStatus = 0;
                            D_8029F258 = 20;
                        }
                    }
 
                    oldKoDuration = actor->koDuration;
                    actor->koDuration = actor->debuffDuration;
                    if (actor->koDuration > 0) {
                        actor->koStatus = STATUS_KEY_DAZE;
                        actor->disableEffect->data.disableX->koDuration = actor->koDuration;
                    } else if (oldKoDuration != actor->koDuration) {
                        actor->koStatus = 0;
                        actor->disableEffect->data.disableX->koDuration = 0;
                    }
                    if (actor->debuff == STATUS_KEY_POISON) {
                        gBattleStatus.flags1 |= BS_FLAGS1_TRIGGER_EVENTS;
                        dispatch_damage_event_actor_0(actor, 1, EVENT_HIT);
                        D_8029F258 = 20;
                    }
                }
            }
            gBattleSubState = BTL_SUBSTATE_9_2;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_9_2) {
        // wait for player HandleEvent script to finish
        if(player->handleEventScript != NULL && does_script_exist(player->handleEventScriptID)) {
            goto WAITING;
        }
        player->handleEventScript = NULL;
 
        // wait for partner HandleEvent script to finish
        if (partner != NULL) {
            if (partner->handleEventScript != NULL && does_script_exist(partner->handleEventScriptID)) {
                goto WAITING;
            }
            partner->handleEventScript = NULL;
        }
 
        // wait for all enemy HandleEvent scripts to finish
        waitingForScript = FALSE;
 
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            actor = battleStatus->enemyActors[i];
            if (actor != NULL && actor->handleEventScript != NULL) {
                if (does_script_exist(actor->handleEventScriptID)) {
                    waitingForScript = TRUE;
                } else {
                    actor->handleEventScript = NULL;
                }
            }
        }
 
        if (waitingForScript) {
            goto WAITING;
        }
 
        if (btl_check_player_defeated() || btl_check_enemies_defeated()) {
            return;
        }
 
        btl_cam_use_preset(BTL_CAM_DEFAULT);
        if (partner == NULL || !(gBattleStatus.flags1 & BS_FLAGS1_PLAYER_IN_BACK)) {
            gBattleSubState = BTL_SUBSTATE_9_4;
        } else if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
            gBattleSubState = BTL_SUBSTATE_9_4;
        } else {
            player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            partner->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            player->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
            partner->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
            state = &partner->state;
            if (!battleStatus->outtaSightActive) {
                partner->state.curPos.x = partner->homePos.x;
                partner->state.curPos.z = partner->homePos.z;
                partner->state.goalPos.x = player->homePos.x;
                partner->state.goalPos.z = player->homePos.z;
            } else {
                partner->state.curPos.x = partner->homePos.x;
                partner->state.curPos.z = partner->homePos.z;
                partner->state.goalPos.x = partner->homePos.x;
                partner->state.goalPos.z = partner->homePos.z + 5.0f;
                partner->homePos.x = player->homePos.x;
                partner->homePos.z = player->homePos.z;
            }
            state->moveTime = 4;
            state->angle = 0.0f;
            gBattleSubState = BTL_SUBSTATE_9_3;
        }
    }
    WAITING:
 
    if (gBattleSubState == BTL_SUBSTATE_9_3) {
        if (partner->state.moveTime != 0) {
            partner->curPos.x += (partner->state.goalPos.x - partner->curPos.x) / partner->state.moveTime;
            partner->curPos.z += (partner->state.goalPos.z - partner->curPos.z) / partner->state.moveTime;
            player->curPos.x += (partner->state.curPos.x - player->curPos.x) / partner->state.moveTime;
            player->curPos.z += (partner->state.curPos.z - player->curPos.z) / partner->state.moveTime;
        }
        partner->curPos.z -= sin_rad(DEG_TO_RAD(partner->state.angle)) * 16.0f;
        partner->yaw = clamp_angle(partner->state.angle);
        player->curPos.z += sin_rad(DEG_TO_RAD(partner->state.angle)) * 16.0f;
        player->yaw = clamp_angle(partner->state.angle);
        partner->state.angle += 90.0f;
 
        if (partner->state.moveTime != 0) {
            partner->state.moveTime--;
        } else {
            partner->curPos.x = partner->state.goalPos.x;
            partner->curPos.z = partner->state.goalPos.z;
            player->curPos.x = partner->state.curPos.x;
            player->curPos.z = partner->state.curPos.z;
            if (!battleStatus->outtaSightActive) {
                partner->homePos.x = partner->curPos.x;
                partner->homePos.z = partner->curPos.z;
                player->homePos.x = player->curPos.x;
                player->homePos.z = player->curPos.z;
            } else {
                player->homePos.x = player->curPos.x;
                player->homePos.z = player->curPos.z;
            }
            gBattleSubState = BTL_SUBSTATE_9_4;
            gBattleStatus.flags1 &= ~BS_FLAGS1_PLAYER_IN_BACK;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_9_4) {
        if (D_8029F258 != 0) {
            D_8029F258--;
        } else {
            if (battleStatus->nextMerleeSpellType == MERLEE_SPELL_DEF_BOOST) {
                battleStatus->merleeDefenseBoost = 3;
                battleStatus->nextMerleeSpellType = MERLEE_SPELL_NONE;
                battleStatus->battlePhase = PHASE_MERLEE_DEFENSE_BONUS;
                script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
                player->takeTurnScript = script;
                player->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PLAYER;
            }
            gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
            player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            player->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
            if (partner != NULL) {
                partner->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
                partner->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
            }
            gBattleSubState = BTL_SUBSTATE_9_5;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PARTNER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_9_5) {
        if (player->takeTurnScript == NULL || (does_script_exist(player->takeTurnScriptID) == 0)) {
            player->takeTurnScript = NULL;
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL && actor->handlePhaseSource != NULL) {
                    battleStatus->battlePhase = PHASE_PLAYER_END;
                    script = start_script(actor->handlePhaseSource, EVT_PRIORITY_A, 0);
                    actor->handlePhaseScript = script;
                    actor->handleBatttlePhaseScriptID = script->id;
                    script->owner1.enemyID = i | ACTOR_CLASS_ENEMY;
                }
            }
            gBattleSubState = BTL_SUBSTATE_9_6;
        }
    }
 
    waitingForScript = FALSE;
    if (gBattleSubState == BTL_SUBSTATE_9_6) {
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            actor = battleStatus->enemyActors[i];
            if (actor != NULL && actor->handlePhaseSource != NULL && does_script_exist(actor->handleBatttlePhaseScriptID)) {
                waitingForScript = TRUE;
            }
        }
        if (!waitingForScript) {
            gBattleSubState = BTL_SUBSTATE_9_7;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_9_7) {
        btl_set_state(BATTLE_STATE_NEXT_ENEMY);
    }
}

Referenced by btl_update().

◆ btl_state_draw_9()

void btl_state_draw_9 ( void )

Definition at line 1528 of file btl_states_actions.c.

1528 {

1529}

Referenced by btl_draw_ui().

◆ btl_state_update_prepare_menu()

void btl_state_update_prepare_menu ( void )

Definition at line 1531 of file btl_states_actions.c.

                                         {
    BattleStatus* battleStatus = &gBattleStatus;
 
    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_JUMP] = -1;
    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_SMASH] = -1;
    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_ITEMS] = -1;
    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP] = -1;
    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_PARTNER] = -1;
    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_STAR_POWER] = -1;
    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_STRATEGY] = -1;
    battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_ABILITY] = -1;
    battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_STAR_POWER] = -1;
    battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_STRATEGY] = -1;
 
    DMA_COPY_SEGMENT(btl_states_menus);
 
    if (battleStatus->flags1 & BS_FLAGS1_PARTNER_ACTING) {
        btl_set_state(BATTLE_STATE_PARTNER_MENU);
    } else if (gBattleSubState == BATTLE_SUBSTATE_PREPARE_MENU_DIPPING) {
        btl_set_state(BATTLE_STATE_PLAYER_MENU);
        gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_DIPPING_1;
    } else {
        btl_set_state(BATTLE_STATE_PLAYER_MENU);
    }
}

Referenced by btl_update().

◆ btl_state_draw_prepare_menu()

void btl_state_draw_prepare_menu ( void )

Definition at line 1557 of file btl_states_actions.c.

1557 {

1558}

Referenced by btl_draw_ui().

◆ btl_state_update_end_turn()

void btl_state_update_end_turn ( void )

Definition at line 1560 of file btl_states_actions.c.

                                     {
    BattleStatus* battleStatus = &gBattleStatus;
    PlayerData* playerData = &gPlayerData;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    Actor* actor;
    Evt* script;
    s32 i;
 
    if (gBattleSubState == BTL_SUBSTATE_END_TURN_INIT) {
        s32 cond = FALSE;
 
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            actor = battleStatus->enemyActors[i];
            if (actor != NULL && actor->handleEventScript != NULL) {
                if (does_script_exist(actor->handleEventScriptID)) {
                    cond = TRUE;
                } else {
                    actor->handleEventScript = NULL;
                }
            }
        }
 
        if (!cond) {
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL && actor->takeTurnScript != NULL) {
                    if (does_script_exist(actor->takeTurnScriptID)) {
                        cond = TRUE;
                    } else {
                        actor->takeTurnScript = NULL;
                    }
                }
            }
 
            if (!cond) {
                btl_cam_use_preset(BTL_CAM_DEFAULT);
                gBattleSubState = BTL_SUBSTATE_END_TURN_CHECK_FOR_SWAP;
            }
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_END_TURN_CHECK_FOR_SWAP) {
        if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
            gBattleSubState = BTL_SUBSTATE_END_TURN_START_SCRIPTS;
        } else if (!(gBattleStatus.flags1 & BS_FLAGS1_PLAYER_IN_BACK)) {
            gBattleSubState = BTL_SUBSTATE_END_TURN_START_SCRIPTS;
        } else {
            player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            partner->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            player->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
            partner->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
            partner->state.curPos.x = partner->homePos.x;
            partner->state.curPos.z = partner->homePos.z;
            partner->state.goalPos.x = player->homePos.x;
            partner->state.goalPos.z = player->homePos.z;
            partner->state.moveTime = 4;
            partner->state.angle = 0.0f;
            gBattleSubState = BTL_SUBSTATE_END_TURN_PERFORM_SWAP;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_END_TURN_PERFORM_SWAP) {
        if (partner->state.moveTime != 0) {
            partner->curPos.x += (partner->state.goalPos.x - partner->curPos.x) / partner->state.moveTime;
            partner->curPos.z += (partner->state.goalPos.z - partner->curPos.z) / partner->state.moveTime;
            player->curPos.x += (partner->state.curPos.x - player->curPos.x) / partner->state.moveTime;
            player->curPos.z += (partner->state.curPos.z - player->curPos.z) / partner->state.moveTime;
        }
        partner->curPos.z -= sin_rad(DEG_TO_RAD(partner->state.angle)) * 16.0f;
        partner->yaw = clamp_angle(partner->state.angle);
        player->curPos.z += sin_rad(DEG_TO_RAD(partner->state.angle)) * 16.0f;
        player->yaw = clamp_angle(partner->state.angle);
        partner->state.angle += 90.0f;
        if (partner->state.moveTime != 0) {
            partner->state.moveTime--;
        } else {
            partner->curPos.x = partner->state.goalPos.x;
            partner->curPos.z = partner->state.goalPos.z;
            player->curPos.x = partner->state.curPos.x;
            player->curPos.z = partner->state.curPos.z;
            partner->homePos.x = partner->curPos.x;
            partner->homePos.z = partner->curPos.z;
            player->homePos.x = player->curPos.x;
            player->homePos.z = player->curPos.z;
            player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            partner->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                gBattleStatus.flags1 |= BS_FLAGS1_PLAYER_IN_BACK;
            } else {
                gBattleStatus.flags1 &= ~BS_FLAGS1_PLAYER_IN_BACK;
            }
            gBattleSubState = BTL_SUBSTATE_END_TURN_START_SCRIPTS;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_END_TURN_START_SCRIPTS) {
        gBattleStatus.flags2 &= ~BS_FLAGS2_HIDE_BUFF_COUNTERS;
        player->disableDismissTimer = 0;
        player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
        if (partner != NULL) {
            player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
            partner->disableDismissTimer = 0;
        }
 
        btl_set_player_idle_anims();
        gBattleStatus.flags1 &= ~BS_FLAGS1_PLAYER_DEFENDING;
        playerData->starPower += SP_PER_SEG;
        if (playerData->starPower > playerData->maxStarPower * SP_PER_BAR) {
            playerData->starPower = playerData->maxStarPower * SP_PER_BAR;
        }
 
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            actor = battleStatus->enemyActors[i];
            if (actor != NULL && actor->handlePhaseSource != NULL) {
                battleStatus->battlePhase = PHASE_ENEMY_END;
                script = start_script(actor->handlePhaseSource, EVT_PRIORITY_A, 0);
                actor->handlePhaseScript = script;
                actor->handleBatttlePhaseScriptID = script->id;
                script->owner1.enemyID = i | ACTOR_ENEMY0;
            }
        }
 
        if (partner != NULL && partner->handlePhaseSource != NULL) {
            battleStatus->battlePhase = PHASE_ENEMY_END;
            script = start_script(partner->handlePhaseSource, EVT_PRIORITY_A, 0);
            partner->handlePhaseScript = script;
            partner->handleBatttlePhaseScriptID = script->id;
            script->owner1.actorID = ACTOR_PARTNER;
        }
        gBattleSubState = BTL_SUBSTATE_END_TURN_AWAIT_SCRIPTS;
    }
 
    // wait for all end turn scripts to finish executing
    if (gBattleSubState == BTL_SUBSTATE_END_TURN_AWAIT_SCRIPTS) {
        s32 cond = FALSE;
 
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            actor = battleStatus->enemyActors[i];
            if (actor != NULL && actor->handlePhaseSource != NULL && does_script_exist(actor->handleBatttlePhaseScriptID)) {
                cond = TRUE;
            }
        }
 
        if (partner != NULL && partner->handlePhaseSource != NULL && does_script_exist(partner->handleBatttlePhaseScriptID)) {
            cond = TRUE;
        }
 
        if (!cond) {
            btl_cam_use_preset(BTL_CAM_DEFAULT);
            gBattleSubState = BTL_SUBSTATE_END_TURN_BEGIN_NEXT;
        }
    }
 
    // proceed to next turn
    switch (gBattleSubState) {
        case BTL_SUBSTATE_END_TURN_BEGIN_NEXT:
        case BTL_SUBSTATE_END_TURN_UNUSED_4:
            btl_set_state(BATTLE_STATE_BEGIN_TURN);
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_end_turn()

void btl_state_draw_end_turn ( void )

Definition at line 1723 of file btl_states_actions.c.

1723 {

1724}

Referenced by btl_draw_ui().

◆ btl_state_update_1C()

void btl_state_update_1C ( void )

Definition at line 1726 of file btl_states_actions.c.

                               {
    btl_cam_use_preset(BTL_CAM_DEFAULT);
    btl_set_state(BATTLE_STATE_PREPARE_MENU);
}

Referenced by btl_update().

◆ btl_state_draw_1C()

void btl_state_draw_1C ( void )

Definition at line 1731 of file btl_states_actions.c.

1731 {

1732}

Referenced by btl_draw_ui().

◆ btl_state_update_victory()

void btl_state_update_victory ( void )

Definition at line 1734 of file btl_states_actions.c.

                                    {
    BattleStatus* battleStatus = &gBattleStatus;
    EncounterStatus* currentEncounter = &gCurrentEncounter;
    PlayerData* playerData = &gPlayerData;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    Evt* script;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_VICTORY_CHECK_OUTTA_SIGHT:
            player->flags &= ~(ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM);
            if (partner != NULL) {
                partner->flags &= ~(ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM);
            }
 
            battleStatus->stateFreezeCount = 0;
            if (battleStatus->outtaSightActive == 0) {
                gBattleSubState = BTL_SUBSTATE_VICTORY_RECOVER_STATUS;
            } else {
                if (battleStatus->outtaSightActive > 0) {
                    D_8029F254 = TRUE;
                }
                battleStatus->battlePhase = PHASE_ENEMY_BEGIN;
                script = start_script(partner->handlePhaseSource, EVT_PRIORITY_A, 0);
                partner->handlePhaseScript = script;
                partner->handleBatttlePhaseScriptID = script->id;
                script->owner1.actorID = ACTOR_PARTNER;
                gBattleSubState = BTL_SUBSTATE_VICTORY_AWAIT_OUTTA_SIGHT;
            }
 
            break;
        case BTL_SUBSTATE_VICTORY_AWAIT_OUTTA_SIGHT:
            if (!does_script_exist(partner->handleBatttlePhaseScriptID)) {
                battleStatus->outtaSightActive = 0;
                gBattleSubState = BTL_SUBSTATE_VICTORY_RECOVER_STATUS;
            }
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_VICTORY_RECOVER_STATUS:
            player->flags &= ~(ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM);
            if (partner != NULL) {
                partner->flags &= ~(ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM);
            }
            gBattleSubState = BTL_SUBSTATE_VICTORY_CHECK_SWAP;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PARTNER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
 
            gBattleStatus.flags1 &= ~BS_FLAGS1_SHOW_PLAYER_DECORATIONS;
            if (player->koStatus == STATUS_KEY_DAZE) {
                dispatch_event_player(EVENT_RECOVER_FROM_KO);
                gBattleSubState = BTL_SUBSTATE_VICTORY_AWAIT_RECOVER_KO;
            }
            player->debuff = 0;
            player->staticStatus = 0;
            player->stoneStatus = 0;
            player->transparentStatus = 0;
            player->koStatus = 0;
            player->koDuration = 0;
            player->disableEffect->data.disableX->koDuration = 0;
 
            if (partner != NULL) {
                if (partner->koStatus == STATUS_KEY_DAZE) {
                    dispatch_event_partner(EVENT_RECOVER_FROM_KO);
                    gBattleSubState = BTL_SUBSTATE_VICTORY_AWAIT_RECOVER_KO;
                }
                partner->debuff = 0;
                partner->staticStatus = 0;
                partner->stoneStatus = 0;
                partner->transparentStatus = 0;
                partner->koStatus = 0;
                partner->koDuration = 0;
                partner->disableEffect->data.disableX->koDuration = 0;
            }
            break;
        case BTL_SUBSTATE_VICTORY_AWAIT_RECOVER_KO:
            if (player->handleEventScript != NULL && does_script_exist(player->handleEventScriptID)) {
                break;
            }
            player->handleEventScript = NULL;
 
            if (partner != NULL) {
                if (partner->handleEventScript != NULL && does_script_exist(partner->handleEventScriptID)) {
                    break;
                }
                partner->handleEventScript = NULL;
            }
            gBattleSubState = BTL_SUBSTATE_VICTORY_CHECK_SWAP;
            break;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_VICTORY_CHECK_SWAP) {
        if (partner == NULL || !(gBattleStatus.flags1 & BS_FLAGS1_PLAYER_IN_BACK)) {
            gBattleSubState = BTL_SUBSTATE_VICTORY_CHECK_MERLEE;
        } else {
            partner->state.curPos.x = partner->curPos.x;
            partner->state.curPos.z = partner->curPos.z;
            partner->state.goalPos.x = player->curPos.x;
            partner->state.goalPos.z = player->curPos.z;
            partner->state.moveTime = 4;
            partner->state.angle = 0.0f;
            gBattleSubState = BTL_SUBSTATE_VICTORY_AWAIT_SWAP;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_VICTORY_AWAIT_SWAP) {
        if (partner->state.moveTime != 0) {
            partner->curPos.x += (partner->state.goalPos.x - partner->curPos.x) / partner->state.moveTime;
            partner->curPos.z += (partner->state.goalPos.z - partner->curPos.z) / partner->state.moveTime;
            player->curPos.x += (partner->state.curPos.x - player->curPos.x) / partner->state.moveTime;
            player->curPos.z += (partner->state.curPos.z - player->curPos.z) / partner->state.moveTime;
        }
        partner->curPos.z += sin_rad(DEG_TO_RAD(partner->state.angle)) * 16.0f;
        partner->yaw = clamp_angle(-partner->state.angle);
        player->curPos.z -= sin_rad(DEG_TO_RAD(partner->state.angle)) * 16.0f;
        player->yaw = clamp_angle(-partner->state.angle);
        partner->state.angle += 90.0f;
 
        if (partner->state.moveTime != 0) {
            partner->state.moveTime--;
        } else {
            partner->curPos.x = partner->state.goalPos.x;
            partner->curPos.z = partner->state.goalPos.z;
            player->curPos.x = partner->state.curPos.x;
            player->curPos.z = partner->state.curPos.z;
            partner->homePos.x = partner->curPos.x;
            partner->homePos.z = partner->curPos.z;
            player->homePos.x = player->curPos.x;
            player->homePos.z = player->curPos.z;
            gBattleSubState = BTL_SUBSTATE_VICTORY_CHECK_MERLEE;
            gBattleStatus.flags1 &= ~BS_FLAGS1_PLAYER_IN_BACK;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_VICTORY_CHECK_MERLEE) {
        btl_cam_use_preset(BTL_CAM_DEFAULT);
        if (battleStatus->nextMerleeSpellType == MERLEE_SPELL_EXP_BOOST) {
            if (battleStatus->totalStarPoints == 0) {
                battleStatus->nextMerleeSpellType = MERLEE_SPELL_NONE;
                playerData->merleeTurnCount = 0;
                playerData->merleeCastsLeft++;
            } else {
                battleStatus->battlePhase = PHASE_MERLEE_EXP_BONUS;
                script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
                player->takeTurnScript = script;
                player->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PLAYER;
            }
        }
        gBattleSubState = BTL_SUBSTATE_VICTORY_AWAIT_MERLEE;
        BattleSubStateDelay = 0;
        gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_VICTORY_AWAIT_MERLEE) {
        if (BattleSubStateDelay != 0) {
            BattleSubStateDelay--;
        } else {
            if (player->takeTurnScript == NULL || !does_script_exist(player->takeTurnScriptID)) {
                player->takeTurnScript = NULL;
                if (battleStatus->nextMerleeSpellType != MERLEE_SPELL_EXP_BOOST) {
                    gBattleSubState = BTL_SUBSTATE_VICTORY_DONE;
                } else {
                    battleStatus->incrementStarPointDelay = 20;
                    battleStatus->nextMerleeSpellType = MERLEE_SPELL_NONE;
                    gBattleSubState = BTL_SUBSTATE_VICTORY_DONE;
                    battleStatus->pendingStarPoints = battleStatus->totalStarPoints
                                            + battleStatus->pendingStarPoints + battleStatus->pendingStarPoints;
                }
            }
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_VICTORY_DONE) {
        if (battleStatus->pendingStarPoints <= 0) {
            if (gBattleStatus.flags1 & BS_FLAGS1_STAR_POINTS_DROPPED) {
                gBattleStatus.flags1 &= ~BS_FLAGS1_BATTLE_FLED;
            }
            if (playerData->battlesWon < 9999) {
                playerData->battlesWon++;
            }
            if (gBattleStatus.flags1 & BS_FLAGS1_BATTLE_FLED) {
                currentEncounter->battleOutcome = OUTCOME_ENEMY_FLED;
            } else {
                currentEncounter->battleOutcome = OUTCOME_PLAYER_WON;
            }
            if (gBattleStatus.flags1 & BS_FLAGS1_DISABLE_CELEBRATION) {
                if (!(gBattleStatus.flags2 & BS_FLAGS2_DONT_STOP_MUSIC)) {
                    bgm_set_song(0, -1, 0, 1500, 8);
                }
                btl_set_state(BATTLE_STATE_END_BATTLE);
            } else {
                btl_set_state(BATTLE_STATE_CELEBRATION);
            }
        }
    }
}

Referenced by btl_update().

◆ btl_state_draw_victory()

void btl_state_draw_victory ( void )

Definition at line 1935 of file btl_states_actions.c.

1935 {

1936}

Referenced by btl_draw_ui().

◆ btl_state_update_end_training_battle()

void btl_state_update_end_training_battle ( void )

Definition at line 1938 of file btl_states_actions.c.

                                                {
    BattleStatus* battleStatus = &gBattleStatus;
    PlayerData* playerData = &gPlayerData;
    EncounterStatus* encounterStatus = &gCurrentEncounter;
    Actor* player = gBattleStatus.playerActor;
    Actor* partner = gBattleStatus.partnerActor;
    Evt* script;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_END_TRAINING_INIT:
            player->flags &= ~(ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM);
            if (partner != NULL) {
                partner->flags &= ~(ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM);
            }
            gBattleSubState = BTL_SUBSTATE_END_TRAINING_CHECK_OUTTA_SIGHT;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PARTNER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
 
            if (player->koStatus == STATUS_KEY_DAZE) {
                dispatch_event_player(EVENT_RECOVER_FROM_KO);
                gBattleSubState = BTL_SUBSTATE_END_TRAINING_AWAIT_RECOVERING;
            }
            player->debuff = 0;
            player->staticStatus = 0;
            player->stoneStatus = 0;
            player->transparentStatus = 0;
            player->koStatus = 0;
            player->koDuration = 0;
            player->disableEffect->data.disableX->koDuration = 0;
            if (partner != NULL) {
                if (partner->koStatus == STATUS_KEY_DAZE) {
                    dispatch_event_partner(EVENT_RECOVER_FROM_KO);
                    gBattleSubState = BTL_SUBSTATE_END_TRAINING_AWAIT_RECOVERING;
                }
                partner->debuff = 0;
                partner->staticStatus = 0;
                partner->stoneStatus = 0;
                partner->transparentStatus = 0;
                partner->koStatus = 0;
                partner->koDuration = 0;
                partner->disableEffect->data.disableX->koDuration = 0;
            }
            break;
        case BTL_SUBSTATE_END_TRAINING_AWAIT_RECOVERING:
            if (player->handleEventScript != NULL && does_script_exist(player->handleEventScriptID)) {
                break;
            }
            player->handleEventScript = NULL;
 
            if (partner != NULL) {
                if (partner->handleEventScript != NULL && does_script_exist(partner->handleEventScriptID)) {
                    break;
                }
                partner->handleEventScript = NULL;
            }
 
            gBattleSubState = BTL_SUBSTATE_END_TRAINING_CHECK_OUTTA_SIGHT;
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_END_TRAINING_CHECK_OUTTA_SIGHT:
            battleStatus->stateFreezeCount = 0;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PARTNER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
 
            if (!battleStatus->outtaSightActive) {
                gBattleSubState = BTL_SUBSTATE_END_TRAINING_RESET_CAM;
            } else {
                battleStatus->battlePhase = PHASE_ENEMY_BEGIN;
                script = start_script(partner->handlePhaseSource, EVT_PRIORITY_A, 0);
                partner->handlePhaseScript = script;
                partner->handleBatttlePhaseScriptID = script->id;
                script->owner1.actorID = ACTOR_PARTNER;
                gBattleSubState = BTL_SUBSTATE_END_TRAINING_AWAIT_OUTTA_SIGHT;
            }
            break;
        case BTL_SUBSTATE_END_TRAINING_AWAIT_OUTTA_SIGHT:
            if (!does_script_exist(partner->handleBatttlePhaseScriptID)) {
                battleStatus->outtaSightActive = FALSE;
                gBattleSubState = BTL_SUBSTATE_END_TRAINING_RESET_CAM;
            }
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_END_TRAINING_RESET_CAM:
            btl_cam_use_preset(BTL_CAM_DEFAULT);
            BattleSubStateDelay = 30;
            gBattleSubState = BTL_SUBSTATE_END_TRAINING_DONE;
            break;
        case BTL_SUBSTATE_END_TRAINING_DONE:
            if (BattleSubStateDelay != 0) {
                BattleSubStateDelay--;
                return;
            }
            if (playerData->trainingsDone < 9999) {
                playerData->trainingsDone++;
            }
            encounterStatus->battleOutcome = OUTCOME_ENEMY_FLED;
            if (!(gBattleStatus.flags2 & BS_FLAGS2_DONT_STOP_MUSIC)) {
                bgm_set_song(0, -1, 0, 1500, 8);
            }
            btl_set_state(BATTLE_STATE_END_BATTLE);
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_end_training_battle()

void btl_state_draw_end_training_battle ( void )

Definition at line 2050 of file btl_states_actions.c.

2050 {

2051}

Referenced by btl_draw_ui().

◆ btl_state_update_end_battle()

void btl_state_update_end_battle ( void )

Definition at line 2053 of file btl_states_actions.c.

                                       {
    EncounterStatus* encounterStatus = &gCurrentEncounter;
    BattleStatus* battleStatus = &gBattleStatus;
    Battle* battle = gCurrentBattlePtr;
    Stage* stage;
    Evt* script;
    s32 i;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_END_BATTLE_INIT:
            BattleScreenFadeAmt = 0;
            if (gGameStatusPtr->debugEnemyContact == DEBUG_CONTACT_DIE_ON_TOUCH) {
                BattleScreenFadeAmt = 255;
            }
            if (encounterStatus->battleOutcome == OUTCOME_PLAYER_LOST && !(gBattleStatus.flags1 & BS_FLAGS1_NO_GAME_OVER)) {
                btl_cam_unfreeze();
                btl_cam_use_preset(BTL_CAM_INTERRUPT);
                set_screen_overlay_color(SCREEN_LAYER_FRONT, 0, 0, 0);
                set_screen_overlay_center(SCREEN_LAYER_FRONT, 0, 160, 120);
            }
            gBattleSubState = BTL_SUBSTATE_END_BATTLE_FADE_OUT;
            break;
        case BTL_SUBSTATE_END_BATTLE_FADE_OUT:
            if (BattleScreenFadeAmt == 255) {
                gBattleSubState = BTL_SUBSTATE_END_BATTLE_EXEC_STAGE_SCRIPT;
                break;
            }
            BattleScreenFadeAmt += battleStatus->endBattleFadeOutRate;
            if (BattleScreenFadeAmt > 255) {
                BattleScreenFadeAmt = 255;
            }
            break;
        case BTL_SUBSTATE_END_BATTLE_EXEC_STAGE_SCRIPT:
            BattleScreenFadeAmt = 255;
            gBattleStatus.flags1 &= ~BS_FLAGS1_ACTORS_VISIBLE;
            if (gCurrentStagePtr == NULL) {
                stage = battle->stage;
            } else {
                stage = gCurrentStagePtr->stage;
            }
            if (stage->postBattle == NULL) {
                gBattleSubState = BTL_SUBSTATE_END_BATTLE_CLEANUP;
                return;
            }
            script = start_script(stage->postBattle, EVT_PRIORITY_A, 0);
            battleStatus->controlScript = script;
            battleStatus->controlScriptID = script->id;
            gBattleSubState = BTL_SUBSTATE_END_BATTLE_AWAIT_STAGE_SCRIPT;
            break;
        case BTL_SUBSTATE_END_BATTLE_AWAIT_STAGE_SCRIPT:
            if (does_script_exist(battleStatus->controlScriptID)) {
                break;
            }
            gBattleSubState = BTL_SUBSTATE_END_BATTLE_CLEANUP;
            // fallthrough
        case BTL_SUBSTATE_END_BATTLE_CLEANUP:
            kill_all_scripts();
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                if (battleStatus->enemyActors[i] != NULL) {
                    btl_delete_actor(battleStatus->enemyActors[i]);
                }
            }
            if (battleStatus->partnerActor != NULL) {
                btl_delete_actor(battleStatus->partnerActor);
            }
 
            btl_delete_player_actor(battleStatus->playerActor);
 
            if (battleStatus->nextMerleeSpellType == MERLEE_SPELL_COIN_BOOST) {
                encounterStatus->hasMerleeCoinBonus = TRUE;
                battleStatus->nextMerleeSpellType = MERLEE_SPELL_NONE;
            }
 
            encounterStatus->damageTaken = battleStatus->damageTaken;
 
            if (gBattleStatus.flags2 & BS_FLAGS2_DROP_WHACKA_BUMP) {
                encounterStatus->dropWhackaBump = TRUE;
            }
 
            remove_all_effects();
            set_windows_visible(0);
 
            if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                decrement_status_bar_disabled();
            }
 
            if (encounterStatus->battleOutcome == OUTCOME_PLAYER_LOST &&
                !(gBattleStatus.flags1 & BS_FLAGS1_NO_GAME_OVER))
            {
                s16 areaID;
                s16 mapID;
 
                btl_set_state(BATTLE_STATE_0);
                gLastDrawBattleState = gBattleState;
                get_map_IDs_by_name_checked("gv_01", &areaID, &mapID);
                gGameStatusPtr->areaID = areaID;
                gGameStatusPtr->mapID = mapID;
                gGameStatusPtr->entryID = gv_01_ENTRY_0;
                set_game_mode(GAME_MODE_GAME_OVER);
            } else {
                btl_set_state(BATTLE_STATE_0);
                gLastDrawBattleState = gBattleState;
                func_8003E514(1);
                set_game_mode(GAME_MODE_END_BATTLE);
            }
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_end_battle()

void btl_state_draw_end_battle ( void )

Definition at line 2162 of file btl_states_actions.c.

                                     {
    Camera* camera = &gCameras[gCurrentCameraID];
 
    if (gCurrentEncounter.battleOutcome == OUTCOME_PLAYER_LOST && !(gBattleStatus.flags1 & BS_FLAGS1_NO_GAME_OVER)) {
        camera->params.basic.offsetY += 256;
        set_screen_overlay_params_front(OVERLAY_SCREEN_MARIO, BattleScreenFadeAmt);
    } else {
        set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, BattleScreenFadeAmt);
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_defend()

void btl_state_update_defend ( void )

Definition at line 2173 of file btl_states_actions.c.

                                   {
    Actor* player = gBattleStatus.playerActor;
    Evt* script;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_DEFEND_INIT:
            gBattleStatus.stateFreezeCount = 0;
            gBattleStatus.battlePhase = PHASE_USE_DEFEND;
            player->takeTurnScript = script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
            player->takeTurnScriptID = script->id;
            gBattleSubState = BTL_SUBSTATE_DEFEND_AWAIT_SCRIPT;
            script->owner1.actorID = ACTOR_PLAYER;
            break;
        case BTL_SUBSTATE_DEFEND_AWAIT_SCRIPT:
            if (!does_script_exist(player->takeTurnScriptID) && gBattleStatus.stateFreezeCount == 0) {
                btl_set_state(BATTLE_STATE_END_PLAYER_TURN);
            }
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_defend()

void btl_state_draw_defend ( void )

Definition at line 2194 of file btl_states_actions.c.

2194 {

2195}

Referenced by btl_draw_ui().

◆ btl_state_update_run_away()

void btl_state_update_run_away ( void )

Definition at line 2197 of file btl_states_actions.c.

                                     {
    BattleStatus* battleStatus = &gBattleStatus;
    PlayerData* playerData = &gPlayerData;
    EncounterStatus* currentEncounter = &gCurrentEncounter;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    Actor* enemy;
    s32 enemyCount;
    f32 totalEscapeChance;
    Evt* script;
    s32 i;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_RUN_AWAY_EXEC_SCRIPT:
            battleStatus->stateFreezeCount = 0;
            gBattleStatus.flags1 &= ~BS_FLAGS1_BATTLE_FLED;
            gBattleStatus.flags2 |= BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
            gBattleStatus.flags2 |= BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
            gBattleStatus.flags2 |= BS_FLAGS2_PARTNER_TURN_USED;
            gBattleStatus.flags2 |= BS_FLAGS2_PLAYER_TURN_USED;
 
            playerData->fleeAttempts++;
            btl_cam_use_preset(BTL_CAM_PLAYER_FLEE);
            btl_cam_target_actor(ACTOR_PLAYER);
 
            // calculate average escape chance
            enemyCount = 0;
            totalEscapeChance = 0.0f;
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL) {
                    if (!(enemy->flags & ACTOR_FLAG_TARGET_ONLY)) {
                        if (!(enemy->flags & ACTOR_FLAG_NO_DMG_APPLY)) {
                            f32 escapeChance = enemy->actorBlueprint->escapeChance;
 
                            if (enemy->debuff == STATUS_KEY_FEAR ||
                                enemy->debuff == STATUS_KEY_DIZZY ||
                                enemy->debuff == STATUS_KEY_PARALYZE ||
                                enemy->debuff == STATUS_KEY_SLEEP ||
                                enemy->debuff == STATUS_KEY_FROZEN ||
                                enemy->debuff == STATUS_KEY_STOP)
                            {
                                escapeChance = 100.0f;
                            }
                            totalEscapeChance += escapeChance;
                            enemyCount++;
                        }
                    }
                }
            }
            player->state.varTable[0] = totalEscapeChance / enemyCount;
 
            if (gGameStatusPtr->debugEnemyContact == DEBUG_CONTACT_AUTO_FLEE) {
                player->state.varTable[0] = 100;
            }
 
            battleStatus->battlePhase = PHASE_RUN_AWAY_START;
            script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
            player->takeTurnScript = script;
            player->takeTurnScriptID = script->id;
            script->owner1.actorID = ACTOR_PLAYER;
            if (partner != NULL && partner->koStatus == 0) {
                script = start_script(partner->takeTurnSource, EVT_PRIORITY_A, 0);
                partner->takeTurnScript = script;
                partner->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PARTNER;
            }
            gBattleSubState = BTL_SUBSTATE_RUN_AWAY_AWAIT_SCRIPT;
            break;
        case BTL_SUBSTATE_RUN_AWAY_AWAIT_SCRIPT:
            if (does_script_exist(player->takeTurnScriptID) || battleStatus->stateFreezeCount != 0) {
                break;
            }
            if (!(gBattleStatus.flags1 & BS_FLAGS1_BATTLE_FLED)) {
                gBattleSubState = BTL_SUBSTATE_RUN_AWAY_EXEC_POST_FAILURE;
            } else {
                currentEncounter->battleOutcome = OUTCOME_PLAYER_FLED;
                if (!is_ability_active(ABILITY_RUNAWAY_PAY)) {
                    gBattleSubState = BTL_SUBSTATE_RUN_AWAY_DONE;
                } else {
                    status_bar_start_blinking_starpoints();
                    func_8023E104();
                    D_8029F264 = 0;
                    D_8029F24C = 0;
                    BattleScreenFadeAmt = 0;
                    // divide reward into 20 increments
                    RunAwayRewardTotal = battleStatus->totalStarPoints * 100;
                    RunAwayRewardStep = 20;
                    RunAwayRewardIncrement = RunAwayRewardTotal / RunAwayRewardStep;
                    gBattleSubState = BTL_SUBSTATE_RUN_AWAY_GIVE_STAR_POINTS;
                }
            }
            break;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_RUN_AWAY_GIVE_STAR_POINTS) {
        if (battleStatus->totalStarPoints != 0) {
            s32 deltaSP;
            s32 prevSP;
 
            RunAwayRewardTotal -= RunAwayRewardIncrement;
            prevSP = battleStatus->totalStarPoints;
            battleStatus->totalStarPoints = RunAwayRewardTotal / 100;
            deltaSP = prevSP - battleStatus->totalStarPoints;
 
            if (deltaSP > 0) {
                sfx_play_sound(SOUND_COIN_PICKUP);
            }
            playerData->starPoints += deltaSP;
            BattleScreenFadeAmt++;
            if (RunAwayRewardStep == 0 && battleStatus->totalStarPoints != 0) {
                playerData->starPoints++;
            }
        }
        if (playerData->starPoints >= 99) {
            playerData->starPoints = 99;
        }
        if (battleStatus->totalStarPoints == 0) {
            if (RunAwayRewardStep != 0) {
                RunAwayRewardStep--;
            } else {
                status_bar_stop_blinking_starpoints();
                func_8023E11C();
                gBattleSubState = BTL_SUBSTATE_RUN_AWAY_DONE;
            }
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_RUN_AWAY_DONE) {
        playerData->battlesFled++;
        if (!(gBattleStatus.flags2 & BS_FLAGS2_DONT_STOP_MUSIC)) {
            bgm_set_song(0, -1, 0, 1500, 8);
        }
        btl_set_state(BATTLE_STATE_END_BATTLE);
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_RUN_AWAY_EXEC_POST_FAILURE:
            battleStatus->battlePhase = PHASE_RUN_AWAY_FAIL;
            script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
            player->takeTurnScript = script;
            player->takeTurnScriptID = script->id;
            script->owner1.actorID = ACTOR_PLAYER;
            if (partner != NULL && partner->koStatus == 0) {
                script = start_script(partner->takeTurnSource, EVT_PRIORITY_A, 0);
                partner->takeTurnScript = script;
                partner->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PARTNER;
            }
            gBattleSubState = BTL_SUBSTATE_RUN_AWAY_AWAIT_POST_FAILURE;
            break;
        case BTL_SUBSTATE_RUN_AWAY_AWAIT_POST_FAILURE:
            if (BattleSubStateDelay != 0) {
                BattleSubStateDelay--;
                return;
            }
            if (!does_script_exist(player->takeTurnScriptID)
                && (partner == NULL || !does_script_exist(partner->takeTurnScriptID))
                && battleStatus->stateFreezeCount == 0
            ) {
                btl_set_state(BATTLE_STATE_9);
            }
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_run_away()

void btl_state_draw_run_away ( void )

Definition at line 2364 of file btl_states_actions.c.

2364 {

2365}

Referenced by btl_draw_ui().

◆ btl_state_update_defeat()

void btl_state_update_defeat ( void )

Definition at line 2367 of file btl_states_actions.c.

                                   {
    BattleStatus* battleStatus = &gBattleStatus;
    EncounterStatus* currentEncounter = &gCurrentEncounter;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    Evt* script;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_DEFEAT_INIT:
            battleStatus->flags1 &= ~BS_FLAGS1_SHOW_PLAYER_DECORATIONS;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PARTNER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
            battleStatus->stateFreezeCount = 0;
 
            if (player->debuff != 0) {
                if (player->debuff == STATUS_KEY_FROZEN) {
                    sfx_play_sound(SOUND_FROZEN_SHATTER);
                    player->icePillarEffect->flags |= FX_INSTANCE_FLAG_DISMISS;
                    player->icePillarEffect = NULL;
                }
                player->debuff = 0;
                player->debuffDuration = 0;
                remove_status_debuff(player->hudElementDataIndex);
                player->koStatus = 0;
                player->koDuration = 0;
                player->disableEffect->data.disableX->koDuration = 0;
            }
 
            btl_cam_use_preset(BTL_CAM_PLAYER_FLEE);
            btl_cam_target_actor(ACTOR_PLAYER);
            battleStatus->battlePhase = PHASE_DEATH;
            script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
            player->takeTurnScript = script;
            player->takeTurnScriptID = script->id;
            script->owner1.actorID = ACTOR_PLAYER;
 
            if (partner != NULL) {
                script = start_script(partner->takeTurnSource, EVT_PRIORITY_A, 0);
                partner->takeTurnScript = script;
                partner->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PARTNER;
            }
            gBattleSubState = BTL_SUBSTATE_DEFEAT_CHECK_LIFE_SHROOM;
            break;
        case BTL_SUBSTATE_DEFEAT_CHECK_LIFE_SHROOM:
            if (does_script_exist(player->takeTurnScriptID) || battleStatus->stateFreezeCount != 0) {
                break;
            }
            if (find_item(ITEM_LIFE_SHROOM) >= 0) {
                battleStatus->battlePhase = PHASE_USE_LIFE_SHROOM;
                script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
                player->takeTurnScript = script;
                player->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PLAYER;
                gBattleSubState = BTL_SUBSTATE_DEFEAT_AWAIT_LIFE_SHROOM;
            } else {
                gBattleSubState = BTL_SUBSTATE_DEFEAT_DONE;
            }
            break;
        case BTL_SUBSTATE_DEFEAT_AWAIT_LIFE_SHROOM:
            if (does_script_exist(player->takeTurnScriptID) || battleStatus->stateFreezeCount != 0) {
                break;
            }
            // never reached if life shroom is successful. its item script calls RestorePreDefeatState,
            // resetting the state to BATTLE_STATE_ENEMY_MOVE (based on the value of gDefeatedBattleState)
            gBattleSubState = BTL_SUBSTATE_DEFEAT_DONE;
            break;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_DEFEAT_DONE) {
        currentEncounter->battleOutcome = OUTCOME_PLAYER_LOST;
        if (!(gBattleStatus.flags2 & BS_FLAGS2_DONT_STOP_MUSIC)) {
            bgm_set_song(0, -1, 0, 1500, 8);
        }
        btl_set_state(BATTLE_STATE_END_BATTLE);
    }
}

Referenced by btl_update().

◆ btl_state_draw_defeat()

void btl_state_draw_defeat ( void )

Definition at line 2447 of file btl_states_actions.c.

2447 {

2448}

Referenced by btl_draw_ui().

◆ btl_state_update_change_partner()

void btl_state_update_change_partner ( void )

Definition at line 2460 of file btl_states_actions.c.

                                           {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    ActorState* state = &player->state;
    PlayerData* playerData = &gPlayerData;
    Actor* enemyActor;
    Evt* script;
    s32 i;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_CHANGE_PARTNER_INIT:
            player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            partner->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            battleStatus->stateFreezeCount = 0;
            gBattleStatus.flags2 |= BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
            btl_cam_use_preset(BTL_CAM_REPOSITION);
            btl_cam_set_target_pos(-89.0, 40.0, -99.0);
            btl_cam_set_zoom(372);
            btl_cam_set_zoffset(0);
            gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemyActor = battleStatus->enemyActors[i];
                if (enemyActor != NULL) {
                    enemyActor->flags &= ~ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                    enemyActor->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
                }
            }
 
            battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_MAIN] = -1;
            BattleSubStateDelay = 10;
            gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_EXEC_PUT_AWAY;
 
        case BTL_SUBSTATE_CHANGE_PARTNER_EXEC_PUT_AWAY:
            if (BattleSubStateDelay != 0) {
                BattleSubStateDelay--;
                break;
            }
            deduct_current_move_fp();
            script = start_script(&BtlPutPartnerAway, EVT_PRIORITY_A, 0);
            battleStatus->controlScript = script;
            battleStatus->controlScriptID = script->id;
            script->owner1.actorID = ACTOR_PARTNER;
            state->unk_18.x = partner->curPos.x;
            state->unk_18.y = 0.0f;
            state->unk_18.z = partner->curPos.z;
            gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_LOAD_NEW_PARTNER;
            break;
        case BTL_SUBSTATE_CHANGE_PARTNER_LOAD_NEW_PARTNER:
            if (does_script_exist(battleStatus->controlScriptID)) {
                break;
            }
            btl_delete_actor(partner);
            playerData->curPartner = battleStatus->unk_1AC;
            load_partner_actor();
            partner = battleStatus->partnerActor;
            partner->scale.x = 0.1f;
            partner->scale.y = 0.1f;
            partner->scale.z = 0.1f;
            partner->state.goalPos.x = state->unk_18.x;
            partner->state.goalPos.y = partner->curPos.y;
            partner->state.goalPos.z = state->unk_18.z;
            partner->curPos.x = player->curPos.x;
            partner->curPos.y = player->curPos.y + 25.0f;
            partner->curPos.z = player->curPos.z;
            gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_EXEC_BRING_OUT;
            break;
        case BTL_SUBSTATE_CHANGE_PARTNER_EXEC_BRING_OUT:
            partner = battleStatus->partnerActor;
            if (partner != NULL) {
                if (does_script_exist(partner->takeTurnScriptID)) {
                    break;
                }
                partner->takeTurnScript = NULL;
            }
 
            script = start_script(&BtlBringPartnerOut, EVT_PRIORITY_A, 0);
            battleStatus->controlScript = script;
            battleStatus->controlScriptID = script->id;
            script->owner1.actorID = ACTOR_PARTNER;
            gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_EXEC_PHASE;
            break;
        case BTL_SUBSTATE_CHANGE_PARTNER_EXEC_PHASE:
            if (does_script_exist(battleStatus->controlScriptID)) {
                break;
            }
            partner = battleStatus->partnerActor;
            if (partner != NULL) {
                if (partner->handlePhaseSource != NULL) {
                    battleStatus->battlePhase = PHASE_PLAYER_BEGIN;
                    script = start_script(partner->handlePhaseSource, EVT_PRIORITY_A, 0);
                    partner->handlePhaseScript = script;
                    partner->handleBatttlePhaseScriptID = script->id;
                    script->owner1.actorID = ACTOR_PARTNER;
                }
            }
            gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_AWAIT_PHASE;
            break;
        case BTL_SUBSTATE_CHANGE_PARTNER_AWAIT_PHASE:
            partner = battleStatus->partnerActor;
            if (partner != NULL) {
                if (partner->handlePhaseSource != NULL && does_script_exist(partner->handleBatttlePhaseScriptID)) {
                    break;
                }
            }
            btl_cam_use_preset(BTL_CAM_DEFAULT);
            gBattleSubState = BTL_SUBSTATE_CHANGE_PARTNER_DONE;
            break;
        case BTL_SUBSTATE_CHANGE_PARTNER_DONE:
            if (battleStatus->stateFreezeCount != 0) {
                break;
            }
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
            if (!(gBattleStatus.flags1 & BS_FLAGS1_PARTNER_ACTING)) {
                if (player_team_is_ability_active(player, ABILITY_QUICK_CHANGE)) {
                    btl_set_state(BATTLE_STATE_PREPARE_MENU);
                } else {
                    btl_set_state(BATTLE_STATE_END_PLAYER_TURN);
                }
            } else {
                if (!player_team_is_ability_active(player, ABILITY_QUICK_CHANGE)) {
                    btl_set_state(BATTLE_STATE_END_PARTNER_TURN);
                } else {
                    btl_set_state(BATTLE_STATE_PREPARE_MENU);
                }
            }
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_change_partner()

void btl_state_draw_change_partner ( void )

Definition at line 2591 of file btl_states_actions.c.

2591 {

2592}

Referenced by btl_draw_ui().

◆ btl_state_update_player_move()

void btl_state_update_player_move ( void )

Definition at line 2594 of file btl_states_actions.c.

                                        {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    s32 messageIndex;
    Actor* actor;
    Evt* script;
    s32 enemyNotDone;
    s8 tipIndex;
    s32 i;
 
    if (gBattleSubState == BTL_SUBSTATE_PLAYER_MOVE_INIT) {
        battleStatus->stateFreezeCount = 0;
        battleStatus->actionResult = ACTION_RESULT_NONE;
        battleStatus->blockResult = BLOCK_RESULT_NONE;
        battleStatus->lastAttackDamage = 0;
        battleStatus->curDamageSource = DMG_SRC_DEFAULT;
        gBattleStatus.flags1 &= ~BS_FLAGS1_AUTO_SUCCEED_ACTION;
        gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
        reset_actor_turn_info();
        player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
        if (partner != NULL) {
            partner->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
        }
        btl_cam_target_actor(ACTOR_PLAYER);
        gBattleStatus.flags1 &= ~BS_FLAGS1_SHOW_PLAYER_DECORATIONS;
        player->statusAfflicted = 0;
        gBattleStatus.flags2 |= BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
        gBattleStatus.flags1 &= ~BS_FLAGS1_YIELD_TURN;
 
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            actor = battleStatus->enemyActors[i];
            if (actor != NULL) {
                actor->statusAfflicted = 0;
            }
        }
 
        for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
            actor = battleStatus->enemyActors[i];
            if (actor != NULL) {
                actor->flags &= ~ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                actor->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            }
        }
 
        if (battleStatus->moveCategory == BTL_MENU_TYPE_JUMP || battleStatus->moveCategory == BTL_MENU_TYPE_SMASH) {
            if (battleStatus->nextMerleeSpellType == MERLEE_SPELL_ATK_BOOST) {
                battleStatus->merleeAttackBoost = 3;
                battleStatus->nextMerleeSpellType = MERLEE_SPELL_NONE;
                battleStatus->battlePhase = PHASE_MERLEE_ATTACK_BONUS;
                script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
                player->takeTurnScript = script;
                player->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PLAYER;
                gBattleStatus.flags1 |= BS_FLAGS1_10000;
                close_action_command_instruction_popup();
                gBattleSubState = BTL_SUBSTATE_PLAYER_MOVE_BEGIN_SHOW_TIP;
            } else {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MOVE_EXECUTE_MOVE;
                gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
            }
        } else {
            gBattleSubState = BTL_SUBSTATE_PLAYER_MOVE_EXECUTE_MOVE;
            gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
        }
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_PLAYER_MOVE_BEGIN_SHOW_TIP:
            if (player->takeTurnScript != NULL && does_script_exist(player->takeTurnScriptID)) {
                break;
            }
            player->takeTurnScript = NULL;
            if (!is_ability_active(ABILITY_BERSERKER)) {
                if (battleStatus->selectedMoveID != MOVE_NONE) {
                    tipIndex = gMoveTable[battleStatus->selectedMoveID].actionTip;
                    if (tipIndex >= 0) {
                        btl_show_battle_message(BTL_MSG_FIRST_ACTION_TIP + tipIndex, 60);
                    }
                }
            }
            BattleSubStateDelay = 2;
            gBattleSubState = BTL_SUBSTATE_PLAYER_MOVE_SHOW_TIP_DELAY;
            break;
        case BTL_SUBSTATE_PLAYER_MOVE_SHOW_TIP_DELAY:
            if (BattleSubStateDelay != 0) {
                BattleSubStateDelay--;
            } else {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MOVE_EXECUTE_MOVE;
            }
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_PLAYER_MOVE_EXECUTE_MOVE:
            gBattleStatus.flags1 &= ~BS_FLAGS1_4000;
            gBattleStatus.flags1 &= ~BS_FLAGS1_10000;
            increment_status_bar_disabled();
            gBattleStatus.flags1 |= BS_FLAGS1_EXECUTING_MOVE;
            reset_all_actor_sounds(player);
            battleStatus->battlePhase = PHASE_EXECUTE_ACTION;
            if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                script = start_script(&EVS_Peach_HandlePhase, EVT_PRIORITY_A, 0);
            } else {
                script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
            }
            player->takeTurnScript = script;
            gBattleSubState = BTL_SUBSTATE_PLAYER_MOVE_HANDLE_RESULTS;
            player->takeTurnScriptID = script->id;
            script->owner1.actorID = ACTOR_PLAYER;
            break;
        case BTL_SUBSTATE_PLAYER_MOVE_HANDLE_RESULTS:
            // wait for player battle phase script to finish
            if (!(gBattleStatus.flags1 & BS_FLAGS1_YIELD_TURN)) {
                if (player->takeTurnScript != NULL && does_script_exist(player->takeTurnScriptID)) {
                    break;
                }
                player->takeTurnScript = NULL;
            }
 
            gBattleStatus.flags1 &= ~BS_FLAGS1_EXECUTING_MOVE;
 
             // wait for player battle event script to finish
            if (player->handleEventScript != NULL && does_script_exist(player->handleEventScriptID)) {
                break;
            }
            player->handleEventScript = NULL;
 
            // wait for partner battle event script to finish
            if (partner != NULL) {
                if (partner->handleEventScript != NULL && does_script_exist(partner->handleEventScriptID)) {
                    break;
                }
                partner->handleEventScript = NULL;
            }
 
            // wait for all enemy battle phase scripts to finish
            enemyNotDone = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL && actor->takeTurnScript != NULL) {
                    if (does_script_exist(actor->takeTurnScriptID)) {
                        enemyNotDone = TRUE;
                    } else {
                        actor->takeTurnScript = NULL;
                    }
                }
            }
            if (enemyNotDone) {
                break;
            }
 
            // wait for all enemy battle event scripts to finish
            enemyNotDone = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL && actor->handleEventScript != NULL) {
                    if (does_script_exist(actor->handleEventScriptID)) {
                        enemyNotDone = TRUE;
                    } else {
                        actor->handleEventScript = NULL;
                    }
                }
            }
            if (enemyNotDone) {
                break;
            }
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL) {
                    actor->flags &= ~ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                }
            }
 
            if (battleStatus->stateFreezeCount != 0) {
                break;
            }
 
            if (gGameStatusPtr->demoBattleFlags & DEMO_BTL_FLAG_ENABLED) {
                btl_set_state(BATTLE_STATE_END_DEMO_BATTLE);
                break;
            }
 
            decrement_status_bar_disabled();
            gBattleStatus.flags1 |= BS_FLAGS1_SHOW_PLAYER_DECORATIONS;
            gBattleStatus.flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PLAYER;
            if (btl_check_player_defeated()) {
                return;
            }
 
            if ((battleStatus->moveCategory == BTL_MENU_TYPE_SMASH)
                && (battleStatus->selectedMoveID != MOVE_SMASH_CHARGE0)
                && (battleStatus->selectedMoveID != MOVE_SMASH_CHARGE)
                && (battleStatus->selectedMoveID != MOVE_SUPER_SMASH_CHARGE)
            ) {
                gBattleStatus.flags1 &= ~BS_FLAGS1_HAMMER_CHARGED;
            }
 
            if ((battleStatus->moveCategory == BTL_MENU_TYPE_JUMP)
                && (battleStatus->selectedMoveID != MOVE_JUMP_CHARGE0)
                && (battleStatus->selectedMoveID != MOVE_JUMP_CHARGE)
                && (battleStatus->selectedMoveID != MOVE_SUPER_JUMP_CHARGE)
            ) {
                gBattleStatus.flags1 &= ~BS_FLAGS1_JUMP_CHARGED;
            }
 
            if (!(gBattleStatus.flags1 & BS_FLAGS1_JUMP_CHARGED)) {
                battleStatus->jumpCharge = 0;
            }
            if (!(gBattleStatus.flags1 & BS_FLAGS1_HAMMER_CHARGED)) {
                battleStatus->hammerCharge = 0;
            }
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL && !(actor->flags & ACTOR_FLAG_NO_DMG_APPLY)) {
                    actor->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
                }
            }
 
            btl_update_ko_status();
 
            enemyNotDone = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL) {
                    if (actor->statusAfflicted != 0) {
                        enemyNotDone = TRUE;
                        break;
                    }
                }
            }
 
            if (!enemyNotDone) {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MOVE_CHECK_PLAYER_STATUS;
            } else {
                btl_cam_use_preset(BTL_CAM_VIEW_ENEMIES);
                switch (actor->statusAfflicted) {
                    case 4:
                        messageIndex = BTL_MSG_ENEMY_DAZED;
                        break;
                    case 6:
                        messageIndex = BTL_MSG_ENEMY_ASLEEP;
                        break;
                    case 7:
                        messageIndex = BTL_MSG_ENEMY_FROZEN;
                        break;
                    case 9:
                        messageIndex = BTL_MSG_ENEMY_POISONED;
                        break;
                    case 10:
                        messageIndex = BTL_MSG_ENEMY_SHRUNK;
                        break;
                    case 5:
                        messageIndex = BTL_MSG_ENEMY_PARALYZED;
                        break;
                    case 11:
                        messageIndex = BTL_MSG_ENEMY_ELECTRIFIED;
                        break;
                    case 8:
                        messageIndex = BTL_MSG_ENEMY_CANT_MOVE;
                        break;
                    default:
                        messageIndex = 0;
                        gBattleSubState = BTL_SUBSTATE_PLAYER_MOVE_CHECK_PLAYER_STATUS;
                        break;
                }
                sfx_play_sound(SOUND_INFLICT_KO);
                btl_show_battle_message(messageIndex, 60);
                for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                    actor = battleStatus->enemyActors[i];
                    if (actor != NULL) {
                        actor->statusAfflicted = 0;
                    }
                }
                gBattleSubState = BTL_SUBSTATE_PLAYER_MOVE_AWAIT_ENEMY_STATUS_POPUP;
            }
            break;
        case BTL_SUBSTATE_PLAYER_MOVE_AWAIT_ENEMY_STATUS_POPUP:
            if (!btl_is_popup_displayed()) {
                btl_cam_use_preset(BTL_CAM_DEFAULT);
                btl_cam_move(15);
                BattleSubStateDelay = 10;
                gBattleSubState = BTL_SUBSTATE_PLAYER_MOVE_POST_ENEMY_STATUS_POPUP;
            }
            break;
        case BTL_SUBSTATE_PLAYER_MOVE_POST_ENEMY_STATUS_POPUP:
            if (BattleSubStateDelay != 0) {
                BattleSubStateDelay--;
            } else {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MOVE_CHECK_PLAYER_STATUS;
            }
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_PLAYER_MOVE_CHECK_PLAYER_STATUS:
            if (player->statusAfflicted != 0) {
                btl_cam_use_preset(BTL_CAM_PLAYER_STATUS_AFFLICTED);
                switch (player->statusAfflicted) {
                    case 4:
                        messageIndex = BTL_MSG_PLAYER_DAZED;
                        break;
                    case 6:
                        messageIndex = BTL_MSG_PLAYER_ASLEEP;
                        break;
                    case 7:
                        messageIndex = BTL_MSG_PLAYER_FROZEN;
                        break;
                    case 9:
                        messageIndex = BTL_MSG_PLAYER_POISONED;
                        break;
                    case 10:
                        messageIndex = BTL_MSG_PLAYER_SHRUNK;
                        break;
                    case 5:
                        messageIndex = BTL_MSG_PLAYER_PARALYZED;
                        break;
                    case 11:
                        messageIndex = BTL_MSG_PLAYER_CHARGED;
                        break;
                    default:
                        messageIndex = 0;
                        gBattleSubState = BTL_SUBSTATE_PLAYER_MOVE_AWAIT_DONE;
                        break;
                }
                btl_show_battle_message(messageIndex, 60);
                player->statusAfflicted = 0;
                player->disableDismissTimer = 0;
                player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
                gBattleSubState = BTL_SUBSTATE_PLAYER_MOVE_AWAIT_PLAYER_STATUS_POPUP;
 
            } else {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MOVE_AWAIT_DONE;
            }
            break;
        case BTL_SUBSTATE_PLAYER_MOVE_AWAIT_PLAYER_STATUS_POPUP:
            if (!btl_is_popup_displayed()) {
                btl_cam_use_preset(BTL_CAM_DEFAULT);
                btl_cam_move(15);
                BattleSubStateDelay = 10;
                gBattleSubState = BTL_SUBSTATE_PLAYER_MOVE_POST_PLAYER_STATUS_POPUP;
            }
            break;
        case BTL_SUBSTATE_PLAYER_MOVE_POST_PLAYER_STATUS_POPUP:
            if (BattleSubStateDelay != 0) {
                BattleSubStateDelay--;
            } else {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MOVE_AWAIT_DONE;
            }
            break;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_PLAYER_MOVE_AWAIT_DONE) {
        if (player->takeTurnScript == NULL || !does_script_exist(player->takeTurnScriptID)) {
            player->takeTurnScript = NULL;
            btl_set_state(BATTLE_STATE_END_PLAYER_TURN);
        }
    }
}

Referenced by btl_update().

◆ btl_state_draw_player_move()

void btl_state_draw_player_move ( void )

Definition at line 2956 of file btl_states_actions.c.

2956 {

2957}

Referenced by btl_draw_ui().

◆ btl_state_update_end_player_turn()

void btl_state_update_end_player_turn ( void )

Definition at line 2959 of file btl_states_actions.c.

                                            {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    Evt* script;
 
    if (gBattleSubState == BTL_SUBSTATE_END_PLAYER_TURN_CHECK_HAPPY) {
        if (battleStatus->moveCategory == BTL_MENU_TYPE_ITEMS && battleStatus->itemUsesLeft >= 2) {
            gBattleSubState = BTL_SUBSTATE_END_PLAYER_TURN_AWAIT_HAPPY;
        } else if (
            !(gBattleStatus.flags2 & BS_FLAGS2_HAS_DRAINED_HP)
            && !is_ability_active(ABILITY_HAPPY_HEART)
            && !is_ability_active(ABILITY_CRAZY_HEART)
            && !is_ability_active(ABILITY_HAPPY_FLOWER)
        ) {
            gBattleSubState = BTL_SUBSTATE_END_PLAYER_TURN_AWAIT_HAPPY;
        } else if (player->stoneStatus == STATUS_KEY_STONE || battleStatus->outtaSightActive) {
            gBattleSubState = BTL_SUBSTATE_END_PLAYER_TURN_AWAIT_HAPPY;
        } else {
            s32 prevHPDrainCount = 0;
            s32 hpRecovery = 0;
            s32 fpRecovery = 0;
 
            if (gBattleStatus.flags2 & BS_FLAGS2_HAS_DRAINED_HP) {
                prevHPDrainCount = battleStatus->hpDrainCount;
                battleStatus->hpDrainCount = 0;
            }
 
            if (rand_int(100) < 50) {
                hpRecovery = is_ability_active(ABILITY_CRAZY_HEART) * 3;
            }
            if (rand_int(100) < 50) {
                hpRecovery += is_ability_active(ABILITY_HAPPY_HEART);
            }
            if (rand_int(100) < 50) {
                fpRecovery = is_ability_active(ABILITY_HAPPY_FLOWER);
            }
 
            if (prevHPDrainCount + hpRecovery + fpRecovery == 0) {
                gBattleSubState = BTL_SUBSTATE_END_PLAYER_TURN_AWAIT_HAPPY;
            } else {
                battleStatus->battlePhase = PHASE_PLAYER_HAPPY;
                script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
                player->takeTurnScript = script;
                player->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PLAYER;
                if (gBattleStatus.flags2 & BS_FLAGS2_HAS_DRAINED_HP) {
                    script->varTable[10] += battleStatus->hpDrainCount;
                    battleStatus->hpDrainCount = 0;
                }
                script->varTable[10] = prevHPDrainCount;
                script->varTable[11] = hpRecovery;
                script->varTable[12] = fpRecovery;
 
                if (script->varTable[10] > 99) {
                    script->varTable[10] = 99;
                }
                if (script->varTable[11] > 99) {
                    script->varTable[11] = 99;
                }
                if (script->varTable[12] > 99) {
                    script->varTable[12] = 99;
                }
 
                gBattleStatus.flags2 &= ~BS_FLAGS2_HAS_DRAINED_HP;
                gBattleSubState = BTL_SUBSTATE_END_PLAYER_TURN_AWAIT_HAPPY;
            }
        }
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_END_PLAYER_TURN_AWAIT_HAPPY:
            if (player->takeTurnScript != NULL && does_script_exist(player->takeTurnScriptID)) {
                break;
            }
            player->takeTurnScript = NULL;
 
            if (!(gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) || (gBattleStatus.flags1 & BS_FLAGS1_PLAYER_IN_BACK)) {
                gBattleSubState = BTL_SUBSTATE_END_PLAYER_TURN_DONE;
            } else {
                player->state.curPos.x = player->homePos.x;
                player->state.curPos.z = player->homePos.z;
                player->state.goalPos.x = partner->homePos.x;
                player->state.goalPos.z = partner->homePos.z;
                player->state.moveTime = 4;
                player->state.angle = 0.0f;
                gBattleSubState = BTL_SUBSTATE_END_PLAYER_TURN_AWAIT_SWAP;
            }
            break;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_END_PLAYER_TURN_AWAIT_SWAP) {
        if (player->state.moveTime != 0) {
            player->curPos.x += (player->state.goalPos.x - player->curPos.x) / player->state.moveTime;
            player->curPos.z += (player->state.goalPos.z - player->curPos.z) / player->state.moveTime;
            partner->curPos.x += (player->state.curPos.x - partner->curPos.x) / player->state.moveTime;
            partner->curPos.z += (player->state.curPos.z - partner->curPos.z) / player->state.moveTime;
        }
        player->curPos.z += sin_rad(DEG_TO_RAD(player->state.angle)) * 16.0f;
        player->yaw = clamp_angle(-player->state.angle);
        partner->curPos.z -= sin_rad(DEG_TO_RAD(player->state.angle)) * 16.0f;
        partner->yaw = clamp_angle(-player->state.angle);
        player->state.angle += 90.0f;
 
        if (player->state.moveTime != 0) {
            player->state.moveTime--;
        } else {
            player->curPos.x = player->state.goalPos.x;
            player->curPos.z = player->state.goalPos.z;
            partner->curPos.x = player->state.curPos.x;
            partner->curPos.z = player->state.curPos.z;
            player->homePos.x = player->curPos.x;
            player->homePos.z = player->curPos.z;
            partner->homePos.x = partner->curPos.x;
            partner->homePos.z = partner->curPos.z;
            gBattleStatus.flags1 |= BS_FLAGS1_PLAYER_IN_BACK;
            gBattleSubState = BTL_SUBSTATE_END_PLAYER_TURN_DONE;
        }
    }
 
    if (gBattleSubState == BTL_SUBSTATE_END_PLAYER_TURN_DONE) {
        if(!btl_check_enemies_defeated()) {
            if (battleStatus->moveCategory == BTL_MENU_TYPE_ITEMS && battleStatus->itemUsesLeft >= 2) {
                btl_cam_use_preset(BTL_CAM_DEFAULT);
                btl_cam_move(10);
                gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
            } else {
                gBattleStatus.flags2 |= BS_FLAGS2_PLAYER_TURN_USED;
            }
 
            if (battleStatus->unk_94 < 0) {
                battleStatus->unk_94 = 0;
                battleStatus->itemUsesLeft = 0;
                btl_set_state(BATTLE_STATE_END_TURN);
                return;
            }
 
            if (battleStatus->itemUsesLeft != 0) {
                battleStatus->itemUsesLeft--;
                if (battleStatus->itemUsesLeft != 0) {
                    // double or triple dip has not run out yet, let the player choose another item
                    btl_set_state(BATTLE_STATE_PREPARE_MENU);
                    gBattleSubState = BATTLE_SUBSTATE_PREPARE_MENU_DIPPING;
                    return;
                }
 
                if (gBattleStatus.flags1 & BS_FLAGS1_HUSTLED) {
                    if (battleStatus->hustleTurns != 0) {
                        battleStatus->hustleTurns--;
                    }
                }
 
                if (battleStatus->hustleTurns != 0 && (gBattleStatus.flags1 & BS_FLAGS1_HUSTLED)) {
                    gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
                    btl_set_state(BATTLE_STATE_PREPARE_MENU);
                    return;
                } else {
                    gBattleStatus.flags1 &= ~BS_FLAGS1_HUSTLED;
                    btl_set_state(BATTLE_STATE_BEGIN_PARTNER_TURN);
                    return;
                }
            }
 
            if (gBattleStatus.flags1 & BS_FLAGS1_HUSTLED) {
                if (battleStatus->hustleTurns != 0) {
                    battleStatus->hustleTurns--;
                }
            }
 
            if (battleStatus->hustleTurns != 0 && (gBattleStatus.flags1 & BS_FLAGS1_HUSTLED)) {
                gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
                btl_set_state(BATTLE_STATE_PREPARE_MENU);
            } else {
                gBattleStatus.flags1 &= ~BS_FLAGS2_HAS_DRAINED_HP;
                if (!(gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE)) {
                    btl_set_state(BATTLE_STATE_BEGIN_PARTNER_TURN);
                } else {
                    btl_set_state(BATTLE_STATE_9);
                }
            }
        }
    }
}

Referenced by btl_update().

◆ btl_state_update_partner_move()

void btl_state_update_partner_move ( void )

Definition at line 3146 of file btl_states_actions.c.

                                         {
    BattleStatus* battleStatus = &gBattleStatus;
    PlayerData* playerData = &gPlayerData;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    Actor* enemyActor;
    Evt* script;
    s8 switchCondition;
    s32 enemyFound;
    s32 messageIndex;
    s32 i;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_PARTNER_MOVE_INIT:
            if (partner == NULL) {
                btl_set_state(BATTLE_STATE_9);
                break;
            }
            battleStatus->stateFreezeCount = 0;
            battleStatus->actionResult = ACTION_RESULT_NONE;
            battleStatus->blockResult = BLOCK_RESULT_NONE;
            battleStatus->curDamageSource = DMG_SRC_DEFAULT;
            gBattleStatus.flags1 &= ~BS_FLAGS1_AUTO_SUCCEED_ACTION;
            gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
            reset_actor_turn_info();
            partner->statusAfflicted = 0;
            partner->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            deduct_current_move_fp();
            btl_cam_target_actor(ACTOR_PARTNER);
            gBattleStatus.flags2 |= BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
            gBattleStatus.flags1 &= ~BS_FLAGS1_YIELD_TURN;
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemyActor = battleStatus->enemyActors[i];
                if (enemyActor != NULL) {
                    enemyActor->statusAfflicted = 0;
                }
            }
            btl_cam_use_preset(BTL_CAM_DEFAULT);
            gBattleSubState = BTL_SUBSTATE_PARTNER_MOVE_EXECUTE_MOVE;
            break;
        case BTL_SUBSTATE_PARTNER_MOVE_EXECUTE_MOVE:
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemyActor = battleStatus->enemyActors[i];
                if (enemyActor != NULL) {
                    enemyActor->flags &= ~ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                    enemyActor->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
                }
            }
 
            increment_status_bar_disabled();
            gBattleStatus.flags1 |= BS_FLAGS1_EXECUTING_MOVE;
            reset_actor_turn_info();
            reset_all_actor_sounds(partner);
            battleStatus->battlePhase = PHASE_EXECUTE_ACTION;
            script = start_script(partner->takeTurnSource, EVT_PRIORITY_A, 0);
            partner->takeTurnScript = script;
            partner->takeTurnScriptID = script->id;
            script->owner1.actorID = ACTOR_PARTNER;
            gBattleSubState = BTL_SUBSTATE_PARTNER_MOVE_HANDLE_RESULTS;
            break;
        case BTL_SUBSTATE_PARTNER_MOVE_HANDLE_RESULTS:
            if (!(gBattleStatus.flags1 & BS_FLAGS1_YIELD_TURN)) {
                if (partner->takeTurnScript != NULL && does_script_exist(partner->takeTurnScriptID)) {
                    break;
                }
                partner->takeTurnScript = NULL;
            }
            gBattleStatus.flags1 &= ~BS_FLAGS1_EXECUTING_MOVE;
 
            if (partner->handleEventScript != NULL && does_script_exist(partner->handleEventScriptID)) {
                break;
            }
            partner->handleEventScript = NULL;
 
            if (player->handleEventScript != NULL && does_script_exist(player->handleEventScriptID)) {
                break;
            }
            player->handleEventScript = NULL;
 
            enemyFound = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemyActor = battleStatus->enemyActors[i];
                if (enemyActor != NULL && enemyActor->takeTurnScript != NULL) {
                    if (does_script_exist(enemyActor->takeTurnScriptID)) {
                        enemyFound = TRUE;
                    } else {
                        enemyActor->takeTurnScript = NULL;
                    }
                }
            }
            if (enemyFound) {
                break;
            }
 
            enemyFound = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemyActor = battleStatus->enemyActors[i];
                if (enemyActor != NULL && enemyActor->handleEventScript != NULL) {
                    if (does_script_exist(enemyActor->handleEventScriptID)) {
                        enemyFound = TRUE;
                    } else {
                        enemyActor->handleEventScript = NULL;
                    }
                }
            }
            if (enemyFound) {
                break;
            }
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemyActor = battleStatus->enemyActors[i];
                if (enemyActor != NULL) {
                    enemyActor->flags &= ~ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                }
            }
 
            if (battleStatus->stateFreezeCount != 0) {
                break;
            }
 
            if (gGameStatusPtr->demoBattleFlags & DEMO_BTL_FLAG_ENABLED) {
                btl_set_state(BATTLE_STATE_END_DEMO_BATTLE);
                break;
            }
            decrement_status_bar_disabled();
            if (playerData->curPartner == PARTNER_GOOMBARIO
                    && battleStatus->moveCategory == BTL_MENU_TYPE_CHANGE_PARTNER
                    && battleStatus->selectedMoveID != MOVE_CHARGE) {
                partner->isGlowing = FALSE;
                gBattleStatus.flags1 &= ~BS_FLAGS1_GOOMBARIO_CHARGED;
            }
            if (btl_check_player_defeated()) {
                return;
            }
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemyActor = battleStatus->enemyActors[i];
                if (enemyActor != NULL) {
                    if (!(enemyActor->flags & ACTOR_FLAG_NO_DMG_APPLY)) {
                        enemyActor->flags |= (ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM);
                    }
                }
            }
 
            btl_update_ko_status();
 
            if (partner->statusAfflicted == STATUS_KEY_DAZE && !btl_are_all_enemies_defeated()) {
                btl_cam_use_preset(BTL_CAM_PARTNER_INJURED);
                btl_show_battle_message(BTL_MSG_PARTNER_INJURED, 60);
                partner->statusAfflicted = 0;
                partner->disableDismissTimer = 0;
                gBattleSubState = BTL_SUBSTATE_PARTNER_MOVE_AWAIT_PARTNER_STATUS_POPUP;
                partner->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            } else {
                gBattleSubState = BTL_SUBSTATE_PARTNER_MOVE_CHECK_ENEMY_STATUS;
            }
            break;
        case BTL_SUBSTATE_PARTNER_MOVE_AWAIT_PARTNER_STATUS_POPUP:
            if (btl_is_popup_displayed()) {
                break;
            }
            btl_cam_use_preset(BTL_CAM_DEFAULT);
            btl_cam_move(15);
            BattleSubStateDelay = 10;
            gBattleSubState = BTL_SUBSTATE_PARTNER_MOVE_POST_PARTNER_STATUS_POPUP;
            break;
        case BTL_SUBSTATE_PARTNER_MOVE_POST_PARTNER_STATUS_POPUP:
            if (BattleSubStateDelay != 0) {
                BattleSubStateDelay--;
            } else {
                gBattleSubState = BTL_SUBSTATE_PARTNER_MOVE_CHECK_ENEMY_STATUS;
            }
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_PARTNER_MOVE_CHECK_ENEMY_STATUS:
            enemyFound = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemyActor = battleStatus->enemyActors[i];
                if (enemyActor != NULL) {
                    if (enemyActor->statusAfflicted != 0) {
                        enemyFound = TRUE;
                        break;
                    }
                }
            }
 
            if (!enemyFound) {
                gBattleSubState = BTL_SUBSTATE_PARTNER_MOVE_DONE;
            } else {
                btl_cam_use_preset(BTL_CAM_VIEW_ENEMIES);
                switchCondition = enemyActor->statusAfflicted - 4;
                switch (switchCondition) {
                    case 0:
                        messageIndex = BTL_MSG_ENEMY_DAZED;
                        break;
                    case 2:
                        messageIndex = BTL_MSG_ENEMY_ASLEEP;
                        break;
                    case 3:
                        messageIndex = BTL_MSG_ENEMY_FROZEN;
                        break;
                    case 5:
                        messageIndex = BTL_MSG_ENEMY_POISONED;
                        break;
                    case 6:
                        messageIndex = BTL_MSG_ENEMY_SHRUNK;
                        break;
                    case 1:
                        messageIndex = BTL_MSG_ENEMY_PARALYZED;
                        break;
                    case 7:
                        messageIndex = BTL_MSG_ENEMY_ELECTRIFIED;
                        break;
                    case 4:
                        messageIndex = BTL_MSG_ENEMY_CANT_MOVE;
                        break;
                    default:
                        messageIndex = 0;
                        gBattleSubState = BTL_SUBSTATE_PARTNER_MOVE_CHECK_ENEMY_STATUS;
                        break;
                }
 
                sfx_play_sound(SOUND_INFLICT_KO);
                btl_show_battle_message(messageIndex, 60);
 
                for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                    enemyActor = battleStatus->enemyActors[i];
                    if (enemyActor != NULL) {
                        enemyActor->statusAfflicted = 0;
                    }
                }
                gBattleSubState = BTL_SUBSTATE_PARTNER_MOVE_AWAIT_ENEMY_STATUS_POPUP;
            }
            break;
        case BTL_SUBSTATE_PARTNER_MOVE_AWAIT_ENEMY_STATUS_POPUP:
            if (btl_is_popup_displayed() == FALSE) {
                btl_cam_use_preset(BTL_CAM_DEFAULT);
                btl_cam_move(15);
                BattleSubStateDelay = 10;
                gBattleSubState = BTL_SUBSTATE_PARTNER_MOVE_POST_ENEMY_STATUS_POPUP;
            }
            break;
        case BTL_SUBSTATE_PARTNER_MOVE_POST_ENEMY_STATUS_POPUP:
            if (BattleSubStateDelay != 0) {
                BattleSubStateDelay--;
            } else {
                gBattleSubState = BTL_SUBSTATE_PARTNER_MOVE_DONE;
            }
            break;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_PARTNER_MOVE_DONE) {
        if (partner->takeTurnScript != NULL && does_script_exist(partner->takeTurnScriptID)) {
            return;
        }
        partner->takeTurnScript = NULL;
        btl_set_state(BATTLE_STATE_END_PARTNER_TURN);
    }
}

Referenced by btl_update().

◆ btl_state_draw_end_player_turn()

void btl_state_draw_end_player_turn ( void )

Definition at line 3143 of file btl_states_actions.c.

3143 {

3144}

Referenced by btl_draw_ui().

◆ btl_state_draw_partner_move()

void btl_state_draw_partner_move ( void )

Definition at line 3410 of file btl_states_actions.c.

3410 {

3411}

Referenced by btl_draw_ui().

◆ btl_state_update_end_partner_turn()

void btl_state_update_end_partner_turn ( void )

Definition at line 3413 of file btl_states_actions.c.

                                             {
    BattleStatus* battleStatus = &gBattleStatus;
 
    if (gBattleSubState == BTL_SUBSTATE_INIT) {
        battleStatus->flags2 |= BS_FLAGS2_PARTNER_TURN_USED;
        if (btl_check_enemies_defeated()) {
            return;
        }
        battleStatus->flags1 &= ~BS_FLAGS1_PARTNER_ACTING;
        battleStatus->flags2 &= ~BS_FLAGS2_OVERRIDE_INACTIVE_PARTNER;
 
        if (battleStatus->unk_94 < 0) {
            battleStatus->unk_94 = 0;
            btl_set_state(BATTLE_STATE_END_TURN);
        } else {
            btl_set_state(BATTLE_STATE_9);
        }
    }
}

Referenced by btl_update().

◆ btl_state_draw_end_partner_turn()

void btl_state_draw_end_partner_turn ( void )

Definition at line 3433 of file btl_states_actions.c.

3433 {

3434}

Referenced by btl_draw_ui().

◆ btl_state_update_next_enemy()

void btl_state_update_next_enemy ( void )

Definition at line 3436 of file btl_states_actions.c.

                                       {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = gBattleStatus.playerActor;
    Actor* partner = gBattleStatus.partnerActor;
    Actor* enemy;
    s32 skipEnemy;
    s32 i;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_NEXT_ENEMY_INIT:
        case BTL_SUBSTATE_NEXT_ENEMY_UNUSED_1:
            i = battleStatus->nextEnemyIndex;
            if (i >= battleStatus->numEnemyActors) {
                // all enemies have been exhausted
                battleStatus->nextEnemyIndex = 0;
                btl_set_state(BATTLE_STATE_END_TURN);
                return;
            }
 
            // find the next eligible enemy
            while (TRUE) {
                if (battleStatus->enemyIDs[i] >= 0) {
                    u16 enemyID = battleStatus->enemyIDs[i];
 
                    enemy = battleStatus->enemyActors[enemyID & 0xFF];
                    if (enemy != NULL) {
                        if (!(enemy->flags & (ACTOR_FLAG_NO_ATTACK | ACTOR_FLAG_TARGET_ONLY))) {
                            break;
                        }
                    }
                }
                i++;
                if (i >= battleStatus->numEnemyActors) {
                    i = 0;
                }
                if (i == 0) {
                    battleStatus->nextEnemyIndex = 0;
                    btl_set_state(BATTLE_STATE_END_TURN);
                    return;
                }
            }
 
            battleStatus->activeEnemyActorID = battleStatus->enemyIDs[i++];
            battleStatus->curTurnEnemy = enemy;
            battleStatus->nextEnemyIndex = i;
 
            skipEnemy = FALSE;
 
            if (enemy->debuff == STATUS_KEY_SLEEP) {
                skipEnemy = TRUE;
            }
            if (enemy->debuff == STATUS_KEY_FEAR) {
                skipEnemy = TRUE;
            }
            if (enemy->debuff == STATUS_KEY_DIZZY) {
                skipEnemy = TRUE;
            }
            if (enemy->debuff == STATUS_KEY_PARALYZE) {
                skipEnemy = TRUE;
            }
            if (enemy->debuff == STATUS_KEY_FROZEN) {
                skipEnemy = TRUE;
            }
            if (enemy->debuff == STATUS_KEY_STOP) {
                skipEnemy = TRUE;
            }
            if (enemy->stoneStatus == STATUS_KEY_STONE) {
                skipEnemy = TRUE;
            }
            if (enemy->flags & ACTOR_FLAG_SKIP_TURN) {
                skipEnemy = TRUE;
            }
 
            if (skipEnemy) {
                // reset state to fetch next enemy
                gBattleSubState = BTL_SUBSTATE_NEXT_ENEMY_INIT;
                return;
            }
 
            battleStatus->stateFreezeCount = 0;
            gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
            gBattleStatus.flags1 &= ~BS_FLAGS1_BATTLE_FLED;
            gBattleStatus.flags1 &= ~BS_FLAGS1_AUTO_SUCCEED_ACTION;
            gBattleStatus.flags1 &= ~BS_FLAGS1_PARTNER_ACTING;
 
            player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            player->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
 
            if (partner != NULL) {
                partner->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
                partner->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
            }
 
            gBattleStatus.flags2 &= ~BS_FLAGS2_PLAYER_TURN_USED;
            gBattleStatus.flags2 &= ~BS_FLAGS2_PARTNER_TURN_USED;
            gBattleStatus.flags2 |= BS_FLAGS2_HIDE_BUFF_COUNTERS;
 
            D_8029F244 = enemy->unk_134;
            if (enemy->handlePhaseSource != NULL) {
                Evt* onTurnChanceScript;
 
                battleStatus->battlePhase = PHASE_ENEMY_BEGIN;
                onTurnChanceScript = start_script(enemy->handlePhaseSource, EVT_PRIORITY_A, 0);
                enemy->handlePhaseScript = onTurnChanceScript;
                enemy->handleBatttlePhaseScriptID = onTurnChanceScript->id;
                onTurnChanceScript->owner1.actorID = battleStatus->activeEnemyActorID;
            }
            gBattleSubState = BTL_SUBSTATE_NEXT_ENEMY_DONE;
            break;
        case BTL_SUBSTATE_NEXT_ENEMY_DONE:
            if (battleStatus->stateFreezeCount == 0) {
                enemy = get_actor(battleStatus->activeEnemyActorID);
 
                if (enemy == NULL || enemy->unk_134 != D_8029F244) {
                    btl_set_state(BATTLE_STATE_NEXT_ENEMY);
                } else {
                    if (enemy->handlePhaseSource == NULL || !does_script_exist(enemy->handleBatttlePhaseScriptID)) {
                        if (battleStatus->unk_94 < 0) {
                            battleStatus->unk_94 = 0;
                            btl_set_state(BATTLE_STATE_END_TURN);
                        } else {
                            btl_set_state(BATTLE_STATE_ENEMY_MOVE);
                        }
                    }
                }
            }
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_next_enemy()

void btl_state_draw_next_enemy ( void )

Definition at line 3566 of file btl_states_actions.c.

3566 {

3567}

Referenced by btl_draw_ui().

◆ btl_state_update_enemy_move()

void btl_state_update_enemy_move ( void )

Definition at line 3569 of file btl_states_actions.c.

                                       {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = gBattleStatus.playerActor;
    Actor* partner = gBattleStatus.partnerActor;
    Actor* enemy;
    s32 i;
 
    Evt* script;
    s32 messageIndex;
    s32 waitingForEnemyScript;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_ENEMY_MOVE_EXECUTE:
        case BTL_SUBSTATE_ENEMY_MOVE_UNUSED_1:
            gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
            gBattleStatus.flags1 &= ~BS_FLAGS1_YIELD_TURN;
            player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            if (partner != NULL) {
                partner->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            }
            battleStatus->stateFreezeCount = 0;
            battleStatus->lastAttackDamage = 0;
            battleStatus->actionQuality = 0;
            battleStatus->actionResult = ACTION_RESULT_NONE;
            battleStatus->blockResult = BLOCK_RESULT_NONE;
            battleStatus->curDamageSource = DMG_SRC_DEFAULT;
            reset_actor_turn_info();
            gBattleStatus.flags1 |= BS_FLAGS1_EXECUTING_MOVE;
            player->statusAfflicted = 0;
            if (partner != NULL) {
                partner->statusAfflicted = 0;
            }
 
            gBattleStatus.flags2 |= BS_FLAGS2_IGNORE_DARKNESS;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL) {
                    enemy->flags &= ~ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                }
            }
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL) {
                    if (!(enemy->flags & ACTOR_FLAG_NO_DMG_APPLY)) {
                        enemy->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
                    }
                }
            }
 
            enemy = battleStatus->curTurnEnemy;
            if (!(enemy->flags & ACTOR_FLAG_NO_ATTACK)) {
                reset_all_actor_sounds(enemy);
                battleStatus->battlePhase = PHASE_EXECUTE_ACTION;
                script = start_script(enemy->takeTurnSource, EVT_PRIORITY_A, 0);
                enemy->takeTurnScript = script;
                enemy->takeTurnScriptID = script->id;
                script->owner1.actorID = battleStatus->activeEnemyActorID;
            }
            gBattleSubState = BTL_SUBSTATE_ENEMY_MOVE_AWAIT_SCRIPTS;
            break;
        case BTL_SUBSTATE_ENEMY_MOVE_AWAIT_SCRIPTS:
            if (player->takeTurnScript != NULL && does_script_exist(player->takeTurnScriptID)) {
                break;
            }
            player->takeTurnScript = NULL;
 
            if (player->handleEventScript != NULL && does_script_exist(player->handleEventScriptID)) {
                break;
            }
            player->handleEventScript = NULL;
 
            if (partner != NULL) {
                if (partner->handleEventScript != NULL && does_script_exist(partner->handleEventScriptID)) {
                    break;
                }
                partner->handleEventScript = NULL;
            }
 
            waitingForEnemyScript = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL && enemy->handleEventScript != NULL) {
                    if (does_script_exist(enemy->handleEventScriptID)) {
                        waitingForEnemyScript = TRUE;
                    } else {
                        enemy->handleEventScript = NULL;
                    }
                }
            }
 
            if (waitingForEnemyScript) {
                break;
            }
 
            if (btl_check_player_defeated()) {
                return;
            }
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL && enemy->takeTurnScript != NULL) {
                    if (does_script_exist(enemy->takeTurnScriptID)) {
                        waitingForEnemyScript = TRUE;
                    } else {
                        enemy->takeTurnScript = NULL;
                    }
                }
            }
 
            if (waitingForEnemyScript && !(gBattleStatus.flags1 & BS_FLAGS1_YIELD_TURN)) {
                break;
            }
 
            gBattleStatus.flags1 &= ~BS_FLAGS1_EXECUTING_MOVE;
            gBattleStatus.flags2 &= ~BS_FLAGS2_IGNORE_DARKNESS;
            if (btl_check_enemies_defeated()) {
                return;
            }
 
            if (battleStatus->stateFreezeCount != 0) {
                break;
            }
 
            if (gGameStatusPtr->demoBattleFlags & DEMO_BTL_FLAG_ENABLED) {
                btl_set_state(BATTLE_STATE_END_DEMO_BATTLE);
            } else {
                btl_update_ko_status();
                if (player->statusAfflicted != 0) {
                    player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
                    if (partner != NULL) {
                        partner->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
                    }
                    btl_cam_use_preset(BTL_CAM_PLAYER_STATUS_AFFLICTED);
 
                    switch (player->statusAfflicted) {
                        case STATUS_KEY_DIZZY:
                            messageIndex = BTL_MSG_PLAYER_DAZED;
                            break;
                        case STATUS_KEY_SLEEP:
                            messageIndex = BTL_MSG_PLAYER_ASLEEP;
                            break;
                        case STATUS_KEY_FROZEN:
                            messageIndex = BTL_MSG_PLAYER_FROZEN;
                            break;
                        case STATUS_KEY_POISON:
                            messageIndex = BTL_MSG_PLAYER_POISONED;
                            break;
                        case STATUS_KEY_SHRINK:
                            messageIndex = BTL_MSG_PLAYER_SHRUNK;
                            break;
                        case STATUS_KEY_PARALYZE:
                            messageIndex = BTL_MSG_PLAYER_PARALYZED;
                            break;
                        default:
                            messageIndex = 0;
                            gBattleSubState = BTL_SUBSTATE_ENEMY_MOVE_CHECK_PARTNER;
                            break;
                    }
                    btl_show_battle_message(messageIndex, 60);
                    player->statusAfflicted = 0;
                    gBattleSubState = BTL_SUBSTATE_ENEMY_MOVE_AWAIT_PLAYER_POPUP_DONE;
                    break;
                } else {
                    gBattleSubState = BTL_SUBSTATE_ENEMY_MOVE_CHECK_PARTNER;
                    break;
                }
            }
            break;
        case BTL_SUBSTATE_ENEMY_MOVE_AWAIT_PLAYER_POPUP_DONE:
            if (!btl_is_popup_displayed()) {
                btl_cam_use_preset(BTL_CAM_DEFAULT);
                btl_cam_move(15);
                BattleSubStateDelay = 10;
                gBattleSubState = BTL_SUBSTATE_ENEMY_MOVE_POST_PLAYER_POPUP_DELAY;
            }
            break;
        case BTL_SUBSTATE_ENEMY_MOVE_POST_PLAYER_POPUP_DELAY:
            if (BattleSubStateDelay != 0) {
                BattleSubStateDelay--;
            } else {
                gBattleSubState = BTL_SUBSTATE_ENEMY_MOVE_CHECK_PARTNER;
                break;
            }
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_ENEMY_MOVE_CHECK_PARTNER:
            if (partner != NULL) {
                if (partner->statusAfflicted == STATUS_KEY_DAZE) {
                    player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
                    partner->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS | ACTOR_FLAG_USING_IDLE_ANIM;
                    btl_cam_use_preset(BTL_CAM_PARTNER_INJURED);
                    btl_show_battle_message(BTL_MSG_PARTNER_INJURED, 60);
                    partner->statusAfflicted = 0;
                    gBattleSubState = BTL_SUBSTATE_ENEMY_MOVE_AWAIT_PARTNER_POPUP_DONE;
                } else {
                    gBattleSubState = BTL_SUBSTATE_ENEMY_MOVE_DONE;
                }
            } else {
                gBattleSubState = BTL_SUBSTATE_ENEMY_MOVE_DONE;
            }
            break;
        case BTL_SUBSTATE_ENEMY_MOVE_AWAIT_PARTNER_POPUP_DONE:
            if (!btl_is_popup_displayed()) {
                btl_cam_use_preset(BTL_CAM_DEFAULT);
                btl_cam_move(15);
                BattleSubStateDelay = 10;
                gBattleSubState = BTL_SUBSTATE_ENEMY_MOVE_POST_PARTNER_POPUP_DELAY;
            }
            break;
        case BTL_SUBSTATE_ENEMY_MOVE_POST_PARTNER_POPUP_DELAY:
            if (BattleSubStateDelay != 0) {
                BattleSubStateDelay--;
            } else {
                gBattleSubState = BTL_SUBSTATE_ENEMY_MOVE_DONE;
            }
            break;
    }
 
    if (gBattleSubState == BTL_SUBSTATE_ENEMY_MOVE_DONE) {
        btl_set_state(BATTLE_STATE_NEXT_ENEMY);
    }
}

Referenced by btl_update().

◆ btl_state_draw_enemy_move()

void btl_state_draw_enemy_move ( void )

Definition at line 3795 of file btl_states_actions.c.

3795 {

3796}

Referenced by btl_draw_ui().

◆ btl_state_update_first_strike()

void btl_state_update_first_strike ( void )

Definition at line 3798 of file btl_states_actions.c.

                                         {
    PlayerData* playerData = &gPlayerData;
    BattleStatus* battleStatus = &gBattleStatus;
    EncounterStatus* encounterStatus = &gCurrentEncounter;
    Actor* player = gBattleStatus.playerActor;
    Actor* partner = gBattleStatus.partnerActor;
    Evt* script;
    Actor* enemy;
    s32 enemyNotDone;
    s32 i;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_FIRST_STRIKE_INIT:
            D_8029F254 = FALSE;
            btl_merlee_on_first_strike();
            if (playerData->playerFirstStrikes < 9999) {
                playerData->playerFirstStrikes++;
            }
 
            // clear rush flags to initialize
            battleStatus->rushFlags = RUSH_FLAG_NONE;
            gBattleStatus.flags2 &= ~BS_FLAGS2_HAS_RUSH;
 
            // set rush flags based on danger/peril status
            if (!(gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE)) {
                if (playerData->curHP <= PERIL_THRESHOLD && is_ability_active(ABILITY_MEGA_RUSH)) {
                    gBattleStatus.flags2 |= BS_FLAGS2_HAS_RUSH;
                    battleStatus->rushFlags |= RUSH_FLAG_MEGA;
                }
                if (playerData->curHP <= DANGER_THRESHOLD && is_ability_active(ABILITY_POWER_RUSH)) {
                    if (!(battleStatus->rushFlags & RUSH_FLAG_MEGA)) {
                        gBattleStatus.flags2 |= BS_FLAGS2_HAS_RUSH;
                        battleStatus->rushFlags |= RUSH_FLAG_POWER;
                    }
                }
            }
 
            // setup dummy 'menu selection' for player move
            switch (encounterStatus->hitType) {
                case ENCOUNTER_TRIGGER_JUMP:
                    battleStatus->moveCategory = BTL_MENU_TYPE_JUMP;
                    battleStatus->selectedMoveID = MOVE_FIRST_STRIKE_JUMP;
                    battleStatus->moveArgument = encounterStatus->hitTier;
                    battleStatus->curTargetListFlags = gMoveTable[MOVE_FIRST_STRIKE_JUMP].flags;
                    break;
                case ENCOUNTER_TRIGGER_HAMMER:
                    battleStatus->moveCategory = BTL_MENU_TYPE_SMASH;
                    battleStatus->selectedMoveID = MOVE_FIRST_STRIKE_HAMMER;
                    battleStatus->moveArgument = encounterStatus->hitTier;
                    battleStatus->curTargetListFlags = gMoveTable[MOVE_FIRST_STRIKE_HAMMER].flags;
                    break;
                case ENCOUNTER_TRIGGER_PARTNER:
                    btl_set_state(BATTLE_STATE_PARTNER_FIRST_STRIKE);
                    return;
            }
            // let the enemy know a first strike is coming
            enemy = get_actor(ACTOR_ENEMY0);
            if (enemy->handleEventSource != NULL) {
                enemy->lastEventType = EVENT_BEGIN_FIRST_STRIKE;
                script = start_script(enemy->handleEventSource, EVT_PRIORITY_A, EVT_FLAG_RUN_IMMEDIATELY);
                enemy->handleEventScript = script;
                enemy->handleEventScriptID = script->id;
                script->owner1.actorID = enemy->actorID;
            }
            gBattleSubState = BTL_SUBSTATE_FIRST_STRIKE_AWAIT_ENEMY_READY;
            break;
        case BTL_SUBSTATE_FIRST_STRIKE_AWAIT_ENEMY_READY:
            enemy = get_actor(ACTOR_ENEMY0);
            if (enemy->handleEventSource != NULL) {
                if (does_script_exist(enemy->handleEventScriptID)) {
                    break;
                } else {
                    enemy->handleEventScript = NULL;
                }
            }
 
            func_80263230(player, enemy);
            battleStatus->stateFreezeCount = 0;
            battleStatus->lastAttackDamage = 0;
            battleStatus->curDamageSource = DMG_SRC_DEFAULT;
            gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
            gBattleStatus.flags2 |= BS_FLAGS2_IS_FIRST_STRIKE;
            gBattleStatus.flags1 &= ~BS_FLAGS1_PARTNER_ACTING;
            increment_status_bar_disabled();
            btl_cam_use_preset(BTL_CAM_MIDPOINT_CLOSE);
            btl_cam_target_actor(ACTOR_PLAYER);
            reset_actor_turn_info();
            // begin the partner turn script
            battleStatus->battlePhase = PHASE_FIRST_STRIKE;
            script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
            player->takeTurnScript = script;
            player->takeTurnScriptID = script->id;
            script->owner1.actorID = ACTOR_PLAYER;
            BattleSubStateDelay = 3;
            gBattleSubState = BTL_SUBSTATE_FIRST_STRIKE_AWAIT_SCRIPTS;
            break;
        case BTL_SUBSTATE_FIRST_STRIKE_AWAIT_SCRIPTS:
            if (BattleSubStateDelay != 0) {
                BattleSubStateDelay--;
            } else {
                D_8029F254 = TRUE;
            }
 
            // wait for player move script
            if (!(gBattleStatus.flags1 & BS_FLAGS1_YIELD_TURN)) {
                if (player->takeTurnScript != NULL && does_script_exist(player->takeTurnScriptID)) {
                    break;
                }
                player->takeTurnScript = NULL;
            }
 
            gBattleStatus.flags1 &= ~BS_FLAGS1_EXECUTING_MOVE;
 
            // wait for player handle event script
            if (player->handleEventScript != NULL && does_script_exist(player->handleEventScriptID)) {
                break;
            }
            player->handleEventScript = NULL;
 
            // wait for partner handle event script
            if (partner != NULL) {
                if (partner->handleEventScript != NULL && does_script_exist(partner->handleEventScriptID)) {
                    break;
                }
                partner->handleEventScript = NULL;
            }
 
            // wait for all enemy turn scripts
            enemyNotDone = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL && enemy->takeTurnScript != NULL) {
                    if (does_script_exist(enemy->takeTurnScriptID)) {
                        enemyNotDone = TRUE;
                    } else {
                        enemy->takeTurnScript = NULL;
                    }
                }
            }
            if (enemyNotDone) {
                break;
            }
 
            // wait for all enemy handle event scripts
            enemyNotDone = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL && enemy->handleEventScript != NULL) {
                    if (does_script_exist(enemy->handleEventScriptID)) {
                        enemyNotDone = TRUE;
                    } else {
                        enemy->handleEventScript = NULL;
                    }
                }
            }
            if (enemyNotDone) {
                break;
            }
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL) {
                    enemy->flags &= ~ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                }
            }
 
            if (battleStatus->stateFreezeCount == 0) {
                decrement_status_bar_disabled();
                if (!(gGameStatusPtr->demoBattleFlags & DEMO_BTL_FLAG_ENABLED)) {
                    Actor* target;
 
                    if (btl_check_player_defeated() || btl_check_enemies_defeated()) {
                        return;
                    }
 
                    target = get_actor(player->targetActorID);
                    if (target != NULL) {
                        if (target->handleEventSource != NULL) {
                            target->lastEventType = EVENT_END_FIRST_STRIKE;
                            script = start_script(target->handleEventSource, EVT_PRIORITY_A, EVT_FLAG_RUN_IMMEDIATELY);
                            target->handleEventScript = script;
                            target->handleEventScriptID = script->id;
                            script->owner1.actorID = target->actorID;
                        }
                    }
                    gBattleSubState = BTL_SUBSTATE_FIRST_STRIKE_AWAIT_ENEMY_DONE;
                } else {
                    btl_set_state(BATTLE_STATE_END_DEMO_BATTLE);
                }
            }
            break;
        case BTL_SUBSTATE_FIRST_STRIKE_AWAIT_ENEMY_DONE:
            enemyNotDone = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                enemy = battleStatus->enemyActors[i];
                if (enemy != NULL && enemy->handleEventScript != NULL) {
                    if (does_script_exist(enemy->handleEventScriptID)) {
                        enemyNotDone = TRUE;
                    } else {
                        enemy->handleEventScript = NULL;
                    }
                }
            }
            if (enemyNotDone) {
                break;
            }
            if (player->takeTurnScript == NULL || !does_script_exist(player->takeTurnScriptID)) {
                player->takeTurnScript = NULL;
                btl_set_state(BATTLE_STATE_BEGIN_TURN);
            }
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_first_stike()

void btl_state_draw_first_stike ( void )

Definition at line 4012 of file btl_states_actions.c.

                                      {
    if (D_802809F6 == -1 && D_8029F254) {
        if (BattleScreenFadeAmt == 0) {
            set_screen_overlay_params_front(OVERLAY_NONE, -1.0f);
        } else {
            if (!(gGameStatusPtr->demoBattleFlags & DEMO_BTL_FLAG_ENABLED)) {
                BattleScreenFadeAmt -= 20;
            } else {
                BattleScreenFadeAmt -= 50;
            }
 
            if (BattleScreenFadeAmt < 0) {
                BattleScreenFadeAmt = 0;
            }
            set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, BattleScreenFadeAmt);
        }
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_partner_striking_first()

void btl_state_update_partner_striking_first ( void )

Definition at line 4031 of file btl_states_actions.c.

                                                   {
    PlayerData* playerData = &gPlayerData;
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    Actor* actor;
    s32 enemyNotDone;
    SelectableTarget* target;
    Evt* script;
    s32 level;
    s32 i;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_PARTNER_FIRST_STRIKE_INIT:
            D_8029F254 = FALSE;
            // setup dummy 'menu selection' for partner move
            level = partner->actorBlueprint->level;
            switch (playerData->curPartner) {
                case PARTNER_KOOPER:
                    battleStatus->moveCategory = BTL_MENU_TYPE_CHANGE_PARTNER;
                    battleStatus->moveArgument = 0;
                    battleStatus->selectedMoveID = level + MOVE_SHELL_TOSS1;
                    battleStatus->curTargetListFlags = gMoveTable[battleStatus->selectedMoveID].flags;
                    break;
                case PARTNER_BOMBETTE:
                    battleStatus->moveCategory = BTL_MENU_TYPE_CHANGE_PARTNER;
                    battleStatus->moveArgument = 0;
                    battleStatus->selectedMoveID = level + MOVE_BODY_SLAM1;
                    battleStatus->curTargetListFlags = gMoveTable[battleStatus->selectedMoveID].flags;
                    break;
            }
            // let the enemy know a first strike is coming
            actor = get_actor(ACTOR_ENEMY0);
            if (actor->handleEventSource != NULL) {
                actor->lastEventType = EVENT_BEGIN_FIRST_STRIKE;
                script = start_script(actor->handleEventSource, EVT_PRIORITY_A, EVT_FLAG_RUN_IMMEDIATELY);
                actor->handleEventScript = script;
                actor->handleEventScriptID = script->id;
                script->owner1.actorID = actor->actorID;
            }
            gBattleSubState = BTL_SUBSTATE_PARTNER_FIRST_STRIKE_AWAIT_ENEMY_READY;
            break;
        case BTL_SUBSTATE_PARTNER_FIRST_STRIKE_AWAIT_ENEMY_READY:
            create_current_pos_target_list(partner);
            target = &partner->targetData[partner->targetIndexList[0]];
            partner->targetActorID = target->actorID;
            partner->targetPartID = target->partID;
            battleStatus->stateFreezeCount = 0;
            battleStatus->lastAttackDamage = 0;
            battleStatus->curDamageSource = DMG_SRC_DEFAULT;
            gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
            gBattleStatus.flags2 |= BS_FLAGS2_IS_FIRST_STRIKE;
            gBattleStatus.flags1 |= BS_FLAGS1_PARTNER_ACTING;
            increment_status_bar_disabled();
            btl_cam_use_preset(BTL_CAM_MIDPOINT_CLOSE);
            btl_cam_target_actor(ACTOR_PARTNER);
            reset_actor_turn_info();
            // begin the partner turn script
            battleStatus->battlePhase = PHASE_FIRST_STRIKE;
            script = start_script(partner->takeTurnSource, EVT_PRIORITY_A, 0);
            partner->takeTurnScript = script;
            partner->takeTurnScriptID = script->id;
            script->owner1.actorID = ACTOR_PARTNER;
            BattleSubStateDelay = 3;
            gBattleSubState = BTL_SUBSTATE_PARTNER_FIRST_STRIKE_AWAIT_SCRIPTS;
            break;
        case BTL_SUBSTATE_PARTNER_FIRST_STRIKE_AWAIT_SCRIPTS:
            if (BattleSubStateDelay != 0) {
                BattleSubStateDelay--;
            } else {
                D_8029F254 = TRUE;
            }
            // wait for partner move script
            if (partner->takeTurnScript != NULL && does_script_exist(partner->takeTurnScriptID)) {
                break;
            }
            partner->takeTurnScript = NULL;
            // wait for partner handle event script
            if (partner->handleEventScript != NULL && does_script_exist(partner->handleEventScriptID)) {
                break;
            }
            partner->handleEventScript = NULL;
            // wait for player handle event script
            if (player->handleEventScript != NULL && does_script_exist(player->handleEventScriptID)) {
                break;
            }
            player->handleEventScript = NULL;
 
            // wait for all enemy turn scripts
            enemyNotDone = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL && actor->takeTurnScript != NULL) {
                    if (does_script_exist(actor->takeTurnScriptID)) {
                        enemyNotDone = TRUE;
                    } else {
                        actor->takeTurnScript = NULL;
                    }
                }
            }
            if (enemyNotDone) {
                break;
            }
 
            // wait for all enemy handle event scripts
            enemyNotDone = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL && actor->handleEventScript != NULL) {
                    if (does_script_exist(actor->handleEventScriptID)) {
                        enemyNotDone = TRUE;
                    } else {
                        actor->handleEventScript = NULL;
                    }
                }
            }
            if (enemyNotDone) {
                break;
            }
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL) {
                    actor->flags &= ~ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                }
            }
 
            if (battleStatus->stateFreezeCount == 0) {
                decrement_status_bar_disabled();
                if (btl_check_player_defeated() || btl_check_enemies_defeated()) {
                    return;
                }
 
                actor = get_actor(partner->targetActorID);
                if (actor != NULL) {
                    if (actor->handleEventSource != NULL) {
                        actor->lastEventType = EVENT_END_FIRST_STRIKE;
                        script = start_script(actor->handleEventSource, EVT_PRIORITY_A, EVT_FLAG_RUN_IMMEDIATELY);
                        actor->handleEventScript = script;
                        actor->handleEventScriptID = script->id;
                        script->owner1.actorID = actor->actorID;
                    }
                }
                gBattleSubState = BTL_SUBSTATE_PARTNER_FIRST_STRIKE_AWAIT_ENEMY_DONE;
            }
            break;
        case BTL_SUBSTATE_PARTNER_FIRST_STRIKE_AWAIT_ENEMY_DONE:
            enemyNotDone = FALSE;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL && actor->handleEventScript != NULL) {
                    if (does_script_exist(actor->handleEventScriptID)) {
                        enemyNotDone = TRUE;
                    } else {
                        actor->handleEventScript = NULL;
                    }
                }
            }
            if (!enemyNotDone) {
                btl_set_state(BATTLE_STATE_BEGIN_TURN);
            }
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_partner_striking_first()

void btl_state_draw_partner_striking_first ( void )

Definition at line 4196 of file btl_states_actions.c.

                                                 {
    if (D_8029F254) {
        if (BattleScreenFadeAmt == 0) {
            set_screen_overlay_params_front(OVERLAY_NONE, -1.0f);
        } else {
            BattleScreenFadeAmt -= 20;
            if (BattleScreenFadeAmt < 0) {
                BattleScreenFadeAmt = 0;
            }
 
            set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, BattleScreenFadeAmt);
        }
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_enemy_striking_first()

void btl_state_update_enemy_striking_first ( void )

Definition at line 4211 of file btl_states_actions.c.

                                                 {
    PlayerData* playerData = &gPlayerData;
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    Evt* script;
    Actor* actor;
    u16* enemyIDs;
    s16 activeEnemyActorID;
    s32 nextEnemyIdx;
    s32 count;
    s32 flags;
    s32 waitingForScript;
    s32 i;
    s32 j;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_ENEMY_FIRST_STRIKE_INIT:
            battleStatus->stateFreezeCount = 0;
            battleStatus->lastAttackDamage = 0;
            battleStatus->curDamageSource = DMG_SRC_DEFAULT;
            playerData->enemyFirstStrikes++;
            battleStatus->flags1 &= ~BS_FLAGS1_MENU_OPEN;
            D_8029F254 = FALSE;
            player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            if (partner != NULL) {
                partner->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
            }
            battleStatus->flags2 |= BS_FLAGS2_IS_FIRST_STRIKE;
            battleStatus->flags2 |= BS_FLAGS2_IGNORE_DARKNESS;
            count = 0;
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL) {
                    battleStatus->enemyIDs[count] = i | ACTOR_ENEMY0;
                    count++;
                }
            }
 
            battleStatus->numEnemyActors = count;
 
            enemyIDs = battleStatus->enemyIDs;
            for (i = 0; i < count - 1; i++) {
                for (j = i + 1; j < count; j++) {
                    s32 iVal = enemyIDs[i];
                    s32 jVal = enemyIDs[j];
 
                    if (battleStatus->enemyActors[iVal & 0xFF]->turnPriority <
                        battleStatus->enemyActors[jVal & 0xFF]->turnPriority)
                    {
                        enemyIDs[i] = jVal;
                        enemyIDs[j] = iVal;
                    }
                }
            }
 
            battleStatus->nextEnemyIndex = 0;
            nextEnemyIdx = 0;
            flags = ACTOR_FLAG_NO_ATTACK | ACTOR_FLAG_TARGET_ONLY;
 
            while (TRUE) {
                actor = battleStatus->enemyActors[battleStatus->enemyIDs[nextEnemyIdx] & 0xFF];
                if (actor == NULL || (actor->flags & flags)) {
                    nextEnemyIdx++;
                    if (nextEnemyIdx >= battleStatus->numEnemyActors) {
                        nextEnemyIdx = 0;
                    }
                } else {
                    break;
                }
            }
 
            activeEnemyActorID = battleStatus->enemyIDs[nextEnemyIdx];
            nextEnemyIdx++;
            battleStatus->curTurnEnemy = actor;
            battleStatus->activeEnemyActorID = activeEnemyActorID;
            if (nextEnemyIdx >= battleStatus->numEnemyActors) {
                nextEnemyIdx = 0;
            }
            battleStatus->nextEnemyIndex = nextEnemyIdx;
            btl_cam_target_actor(battleStatus->activeEnemyActorID);
            actor = battleStatus->curTurnEnemy;
            reset_actor_turn_info();
            battleStatus->battlePhase = PHASE_FIRST_STRIKE;
            script = start_script(actor->takeTurnSource, EVT_PRIORITY_A, 0);
            actor->takeTurnScript = script;
            BattleSubStateDelay = 3;
            actor->takeTurnScriptID = script->id;
            gBattleSubState = BTL_SUBSTATE_ENEMY_FIRST_STRIKE_AWAIT_SCRIPTS;
            script->owner1.actorID = battleStatus->activeEnemyActorID;
            break;
        case BTL_SUBSTATE_ENEMY_FIRST_STRIKE_AWAIT_SCRIPTS:
            if (BattleSubStateDelay != 0) {
                BattleSubStateDelay--;
            } else {
                D_8029F254 = TRUE;
            }
 
            // wait for current enemy TakeTurn script to finish
            actor = battleStatus->curTurnEnemy;
            if (actor->takeTurnScript != NULL && does_script_exist(actor->takeTurnScriptID)) {
                break;
            }
            actor->takeTurnScript = NULL;
 
            // wait for player HandleEvent script to finish (may have been triggered by enemy Take Turn)
            if (player->handleEventScript != NULL && does_script_exist(player->handleEventScriptID)) {
                break;
            }
            player->handleEventScript = NULL;
 
            // wait for partner HandleEvent script to finish (may have been triggered by enemy Take Turn)
            if (partner != NULL) {
                if (partner->handleEventScript != NULL && does_script_exist(partner->handleEventScriptID)) {
                    break;
                }
                partner->handleEventScript = NULL;
            }
 
            // wait for all enemy TakeTurn scripts to finish
            waitingForScript = FALSE;
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL && actor->takeTurnScript != NULL) {
                    if (does_script_exist(actor->takeTurnScriptID)) {
                        waitingForScript = TRUE;
                    } else {
                        actor->takeTurnScript = NULL;
                    }
                }
            }
 
            if (waitingForScript) {
                break;
            }
 
            // wait for all enemy HandleEvent scripts to finish
            waitingForScript = FALSE;
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL && actor->handleEventScript != NULL) {
                    if (does_script_exist(actor->handleEventScriptID)) {
                        waitingForScript = TRUE;
                    } else {
                        actor->handleEventScript = NULL;
                    }
                }
            }
 
            if (waitingForScript) {
                break;
            }
 
            // reset state
            gBattleStatus.flags2 &= ~BS_FLAGS2_IGNORE_DARKNESS;
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                actor = battleStatus->enemyActors[i];
                if (actor != NULL) {
                    actor->flags &= ~ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                }
            }
 
            if (battleStatus->stateFreezeCount == 0) {
                if (btl_check_player_defeated() || btl_check_enemies_defeated()) {
                    return;
                }
                btl_set_state(BATTLE_STATE_BEGIN_TURN);
            }
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_enemy_striking_first()

void btl_state_draw_enemy_striking_first ( void )

Definition at line 4386 of file btl_states_actions.c.

                                               {
    if (D_8029F254) {
        if (BattleScreenFadeAmt == 0) {
            set_screen_overlay_params_front(OVERLAY_NONE, -1.0f);
        } else {
            BattleScreenFadeAmt -= 20;
            if (BattleScreenFadeAmt < 0) {
                BattleScreenFadeAmt = 0;
            }
 
            set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, BattleScreenFadeAmt);
        }
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_end_demo_battle()

void btl_state_update_end_demo_battle ( void )

Definition at line 4401 of file btl_states_actions.c.

                                            {
    BattleStatus* battleStatus = &gBattleStatus;
    Battle* battle = gCurrentBattlePtr;
    Stage* stage;
    s32 i;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_END_DEMO_BATTLE_INIT:
            BattleScreenFadeAmt = 0;
            if (D_802809F6 == -1) {
                if (DemoBattleBeginDelay != 0) {
                    DemoBattleBeginDelay--;
                    break;
                }
            }
            gBattleSubState = BTL_SUBSTATE_END_DEMO_BATTLE_FADE_OUT;
            break;
        case BTL_SUBSTATE_END_DEMO_BATTLE_FADE_OUT:
            switch (D_802809F6) {
                case 255:
                    gBattleSubState = BTL_SUBSTATE_END_DEMO_BATTLE_EXEC_STAGE_SCRIPT;
                    return;
                case -1:
                    if (BattleScreenFadeAmt == 255) {
                        gBattleSubState = BTL_SUBSTATE_END_DEMO_BATTLE_EXEC_STAGE_SCRIPT;
                        return;
                    }
                    BattleScreenFadeAmt += 50;
                    if (BattleScreenFadeAmt > 255) {
                        BattleScreenFadeAmt = 255;
                    }
                    return;
            }
            break;
        case BTL_SUBSTATE_END_DEMO_BATTLE_EXEC_STAGE_SCRIPT:
            BattleScreenFadeAmt = 255;
            gBattleStatus.flags1 &= ~BS_FLAGS1_ACTORS_VISIBLE;
            if (gCurrentStagePtr == NULL) {
                stage = battle->stage;
            } else {
                stage = gCurrentStagePtr->stage;
            }
 
            if (stage->postBattle == NULL) {
                gBattleSubState = BTL_SUBSTATE_END_DEMO_BATTLE_CLEANUP;
            } else {
                battleStatus->controlScript = start_script(stage->postBattle, EVT_PRIORITY_A, 0);
                battleStatus->controlScriptID = battleStatus->controlScript->id;
                gBattleSubState = BTL_SUBSTATE_END_DEMO_BATTLE_AWAIT_STAGE_SCRIPT;
            }
            break;
        case BTL_SUBSTATE_END_DEMO_BATTLE_AWAIT_STAGE_SCRIPT:
            if (does_script_exist(battleStatus->controlScriptID)) {
                break;
            }
            gBattleSubState = BTL_SUBSTATE_END_DEMO_BATTLE_CLEANUP;
            //fallthrough
        case BTL_SUBSTATE_END_DEMO_BATTLE_CLEANUP:
            kill_all_scripts();
 
            for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
                Actor* enemy = battleStatus->enemyActors[i];
 
                if (enemy != NULL) {
                    btl_delete_actor(enemy);
                }
            }
 
            if (battleStatus->partnerActor != NULL) {
                btl_delete_actor(battleStatus->partnerActor);
            }
 
            btl_delete_player_actor(battleStatus->playerActor);
            remove_all_effects();
            set_windows_visible(WINDOW_GROUP_ALL);
 
            if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                decrement_status_bar_disabled();
            }
 
            if (D_802809F6 != -1) {
                gGameStatusPtr->nextDemoScene = LAST_DEMO_SCENE_IDX;
            }
 
            btl_set_state(BATTLE_STATE_0);
            gLastDrawBattleState = gBattleState;
            set_game_mode(GAME_MODE_END_BATTLE);
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_end_demo_battle()

void btl_state_draw_end_demo_battle ( void )

Definition at line 4492 of file btl_states_actions.c.

                                          {
    if (D_802809F6 == -1) {
        set_screen_overlay_color(SCREEN_LAYER_FRONT, 0, 0, 0);
        set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, BattleScreenFadeAmt);
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_player_menu()

void btl_state_update_player_menu ( void )

Definition at line 2237 of file btl_states_menus.c.

                                        {
    BattleStatus* battleStatus = &gBattleStatus;
    PlayerData* playerData = &gPlayerData;
    Actor* playerActor = battleStatus->playerActor;
    Actor* partnerActor = battleStatus->partnerActor;
    PopupMenu* popup = &D_802ACCD0;
    MoveData* moveData;
    s32 entryIdx, initialPos;
    s32 i;
    s32 submenuResult;
    s32 jumpTargetCount, hammerTargetCount, jumpChance;
    ItemData* itemData;
    s32 starBeamLevel;
    s32 currentSubmenu;
    s32 currentSubmenu2;
    IconHudScriptPair* hudScriptPair;
    PartnerPopupProperties* prop;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_PLAYER_MENU_INIT:
            battleStatus->moveCategory = BTL_MENU_TYPE_INVALID;
            battleStatus->selectedMoveID = 0;
            battleStatus->curAttackElement = 0;
            if (!can_switch_to_player()) {
                btl_set_state(BATTLE_STATE_END_PLAYER_TURN);
                return;
            }
            btl_cam_use_preset(BTL_CAM_DEFAULT);
            btl_cam_move(10);
            if (!(battleStatus->flags1 & BS_FLAGS1_PLAYER_IN_BACK)) {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_CREATE_MAIN_MENU;
            } else {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_PERFORM_SWAP;
                partnerActor->state.curPos.x = partnerActor->homePos.x;
                partnerActor->state.curPos.z = partnerActor->homePos.z;
                partnerActor->state.goalPos.x = playerActor->homePos.x;
                partnerActor->state.goalPos.z = playerActor->homePos.z;
                partnerActor->state.moveTime = 4;
                partnerActor->state.angle = 0.0f;
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_PERFORM_SWAP:
            if (partnerActor->state.moveTime != 0) {
                partnerActor->curPos.x += (partnerActor->state.goalPos.x - partnerActor->curPos.x) / partnerActor->state.moveTime;
                partnerActor->curPos.z += (partnerActor->state.goalPos.z - partnerActor->curPos.z) / partnerActor->state.moveTime;
                playerActor->curPos.x += (partnerActor->state.curPos.x - playerActor->curPos.x) / partnerActor->state.moveTime;
                playerActor->curPos.z += (partnerActor->state.curPos.z - playerActor->curPos.z) / partnerActor->state.moveTime;
            }
            partnerActor->curPos.z -= sin_rad(DEG_TO_RAD(partnerActor->state.angle)) * 16.0f;
            partnerActor->yaw = clamp_angle(-partnerActor->state.angle);
            playerActor->curPos.z += sin_rad(DEG_TO_RAD(partnerActor->state.angle)) * 16.0f;
            playerActor->yaw = clamp_angle(-partnerActor->state.angle);
            partnerActor->state.angle += 90.0f;
            if (partnerActor->state.moveTime != 0) {
                partnerActor->state.moveTime--;
            } else {
                partnerActor->curPos.x = partnerActor->state.goalPos.x;
                partnerActor->curPos.z = partnerActor->state.goalPos.z;
                playerActor->curPos.x = partnerActor->state.curPos.x;
                playerActor->curPos.z = partnerActor->state.curPos.z;
                partnerActor->homePos.x = partnerActor->curPos.x;
                partnerActor->homePos.z = partnerActor->curPos.z;
                playerActor->homePos.x = playerActor->curPos.x;
                playerActor->homePos.z = playerActor->curPos.z;
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_CREATE_MAIN_MENU;
                battleStatus->flags1 &= ~BS_FLAGS1_PLAYER_IN_BACK;
            }
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_PLAYER_MENU_CREATE_MAIN_MENU:
            gBattleStatus.flags1 |= BS_FLAGS1_MENU_OPEN;
            playerActor->flags &= ~ACTOR_FLAG_USING_IDLE_ANIM;
            playerActor->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            if (partnerActor != NULL) {
                partnerActor->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
                partnerActor->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            }
            btl_check_can_change_partner();
            btl_init_menu_items();
            btl_init_menu_boots();
            btl_init_menu_hammer();
            if (player_team_is_ability_active(playerActor, ABILITY_BERSERKER)) {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_BERSERKER_CHOOSE;
                break;
            }
 
            entryIdx = 0;
            initialPos = 2;
            if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_MAIN] < 0) {
                battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_MAIN] = 0;
            }
 
            // strategies menu category
            battle_menu_submenuIDs[entryIdx] = BTL_MENU_TYPE_STRATEGIES;
            BattleMenu_OptionEnabled[entryIdx] = TRUE;
            BattleMenu_HudScripts[entryIdx] = battle_menu_StrategiesHudScript.enabled;
            BattleMenu_TitleMessages[entryIdx] = BattleMenu_CenteredMessages[BTL_MENU_TYPE_STRATEGIES];
            if (battleStatus->actionCommandMode == AC_MODE_TUTORIAL || gBattleStatus.flags1 & BS_FLAGS1_TUTORIAL_BATTLE) {
                BattleMenu_TitleMessages[entryIdx] = MSG_Menus_EndTraining_Centered;
            }
            battle_menu_isMessageDisabled[entryIdx] = 0;
            if (!(battleStatus->enabledMenusFlags & BTL_MENU_ENABLED_STRATEGIES)) {
                BattleMenu_HudScripts[entryIdx] = battle_menu_StrategiesHudScript.disabled;
                BattleMenu_OptionEnabled[entryIdx] = FALSE;
                battle_menu_isMessageDisabled[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
            }
            if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_MAIN] == BTL_MENU_TYPE_STRATEGIES) {
                initialPos = entryIdx;
            }
            entryIdx++;
 
            // items menu category
            if (battleStatus->menuStatus[0] >= 0) {
                BattleMenu_HudScripts[entryIdx] = battle_menu_ItemHudScripts.enabled;
                battle_menu_submenuIDs[entryIdx] = BTL_MENU_TYPE_ITEMS;
                BattleMenu_OptionEnabled[entryIdx] = TRUE;
                BattleMenu_TitleMessages[entryIdx] = BattleMenu_CenteredMessages[BTL_MENU_TYPE_ITEMS];
 
                if(battleStatus->menuStatus[0] == 0) {
                    BattleMenu_HudScripts[entryIdx] = battle_menu_ItemHudScripts.disabled;
                    BattleMenu_OptionEnabled[entryIdx] = FALSE;
                    battle_menu_isMessageDisabled[entryIdx] = BTL_MSG_NO_ITEM_TARGET;
                }
 
                if (!(battleStatus->enabledMenusFlags & BTL_MENU_ENABLED_ITEMS)) {
                    BattleMenu_HudScripts[entryIdx] = battle_menu_ItemHudScripts.disabled;
                    BattleMenu_OptionEnabled[entryIdx] = FALSE;
                    battle_menu_isMessageDisabled[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
                }
 
                if (battleStatus->itemLossTurns >= 0) {
                    BattleMenu_HudScripts[entryIdx] = battle_menu_ItemHudScripts.disabled;
                    BattleMenu_OptionEnabled[entryIdx] = FALSE;
                    battle_menu_isMessageDisabled[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
                }
 
                if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_MAIN] == BTL_MENU_TYPE_ITEMS) {
                    initialPos = entryIdx;
                }
 
                entryIdx++;
            }
 
            // jump menu category
            BattleMenu_HudScripts[entryIdx] = battle_menu_JumpHudScripts[playerData->bootsLevel + 1].enabled;
            battle_menu_submenuIDs[entryIdx] = BTL_MENU_TYPE_JUMP;
            BattleMenu_OptionEnabled[entryIdx] = TRUE;
            BattleMenu_TitleMessages[entryIdx] = BattleMenu_CenteredMessages[BTL_MENU_TYPE_JUMP];
 
            if (battleStatus->menuStatus[1] <= 0) {
                BattleMenu_HudScripts[entryIdx] = battle_menu_JumpHudScripts[0].enabled;
                BattleMenu_OptionEnabled[entryIdx] = FALSE;
                battle_menu_isMessageDisabled[entryIdx] = BTL_MSG_NO_JUMP_TARGET;
            }
            if (!(battleStatus->enabledMenusFlags & BTL_MENU_ENABLED_JUMP)) {
                BattleMenu_HudScripts[entryIdx] = battle_menu_JumpHudScripts[0].disabled;
                BattleMenu_OptionEnabled[entryIdx] = FALSE;
                battle_menu_isMessageDisabled[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
            }
            if (battleStatus->jumpLossTurns >= 0) {
                BattleMenu_HudScripts[entryIdx] = battle_menu_JumpHudScripts[0].disabled;
                BattleMenu_OptionEnabled[entryIdx] = FALSE;
                battle_menu_isMessageDisabled[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
            }
            if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_MAIN] == BTL_MENU_TYPE_JUMP) {
                initialPos = entryIdx;
            }
            entryIdx++;
 
            // hammer menu category
            if (playerData->hammerLevel >= 0) {
                BattleMenu_HudScripts[entryIdx] = battle_menu_HammerHudScripts[playerData->hammerLevel + 1].enabled;
                battle_menu_submenuIDs[entryIdx] = BTL_MENU_TYPE_SMASH;
                BattleMenu_OptionEnabled[entryIdx] = TRUE;
                BattleMenu_TitleMessages[entryIdx] = BattleMenu_CenteredMessages[BTL_MENU_TYPE_SMASH];
                if (battleStatus->menuStatus[2] <= 0) {
                    BattleMenu_HudScripts[entryIdx] = battle_menu_HammerHudScripts[0].enabled;
                    BattleMenu_OptionEnabled[entryIdx] = FALSE;
                    battle_menu_isMessageDisabled[entryIdx] = BTL_MSG_NO_HAMMER_TARGET;
                }
                if (!(battleStatus->enabledMenusFlags & BTL_MENU_ENABLED_SMASH)) {
                    BattleMenu_HudScripts[entryIdx] = battle_menu_HammerHudScripts[0].disabled;
                    BattleMenu_OptionEnabled[entryIdx] = FALSE;
                    battle_menu_isMessageDisabled[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
                }
                if (battleStatus->hammerLossTurns >= 0) {
                    BattleMenu_HudScripts[entryIdx] = battle_menu_HammerHudScripts[0].disabled;
                    BattleMenu_OptionEnabled[entryIdx] = FALSE;
                    battle_menu_isMessageDisabled[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
                }
                if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_MAIN] == BTL_MENU_TYPE_SMASH) {
                    initialPos = entryIdx;
                }
                entryIdx++;
            }
 
            // star powers menu category
            if (playerData->maxStarPower != 0) {
                BattleMenu_HudScripts[entryIdx] = battle_menu_StarPowerHudScripts.enabled;
                battle_menu_submenuIDs[entryIdx] = BTL_MENU_TYPE_STAR_POWERS;
                BattleMenu_OptionEnabled[entryIdx] = TRUE;
                BattleMenu_TitleMessages[entryIdx] = BattleMenu_CenteredMessages[BTL_MENU_TYPE_STAR_POWERS];
                battle_menu_isMessageDisabled[entryIdx] = 0;
                if (!(battleStatus->enabledMenusFlags & BTL_MENU_ENABLED_STAR_POWERS)) {
                    BattleMenu_HudScripts[entryIdx] = battle_menu_StarPowerHudScripts.disabled;
                    BattleMenu_OptionEnabled[entryIdx] = FALSE;
                    battle_menu_isMessageDisabled[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
                }
                if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_MAIN] == BTL_MENU_TYPE_STAR_POWERS) {
                    initialPos = entryIdx;
                }
                entryIdx++;
            }
 
            BattleMenu_NumOptions = entryIdx;
            D_802AD0A8 = 0;
            D_802AD0B0 = initialPos;
            D_802AD100 = 2 - initialPos;
            if (can_switch_to_partner()) {
                BattleMenu_ShowSwapIcons = TRUE;
            } else {
                BattleMenu_ShowSwapIcons = FALSE;
            }
            btl_main_menu_init();
            D_802ACC60 = 8;
            BattleMenu_SwapDelay = 0;
            gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_CHOOSE_CATEGORY;
            break;
        case BTL_SUBSTATE_PLAYER_MENU_CHOOSE_CATEGORY:
            if (battleStatus->hustleTurns != 0) {
                set_actor_anim(ACTOR_PLAYER, 0, ANIM_Mario1_ThinkingRun);
            } else {
                set_actor_anim(ACTOR_PLAYER, 0, get_player_anim_for_status(STATUS_KEY_THINKING));
            }
            submenuResult = btl_main_menu_update();
            if (BattleMenu_SwapDelay != 0) {
                BattleMenu_SwapDelay--;
            } else if (!(gBattleStatus.flags1 & BS_FLAGS1_TUTORIAL_BATTLE) && (gGameStatusPtr->pressedButtons[0] & BUTTON_Z)) {
                if (can_switch_to_partner() && battleStatus->hustleTurns != 1) {
                    sfx_play_sound(SOUND_PARTNER_SWAP_BATTLE_POS);
                    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_MAIN] = battle_menu_submenuIDs[BattleMenu_CurPos + BattleMenu_HomePos];
                    btl_main_menu_destroy();
                    btl_set_state(BATTLE_STATE_SWITCH_TO_PARTNER);
                } else if (partnerActor != NULL && !(partnerActor->flags & BS_FLAGS1_YIELD_TURN) && battleStatus->hustleTurns != 1) {
                    sfx_play_sound(SOUND_MENU_ERROR);
                    gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_MAIN_SHOW_CANT_SWAP;
                }
                break;
            }
 
            if (D_802ACC60 != 0) {
                D_802ACC60--;
                break;
            }
 
            if (submenuResult == 0) {
                break;
            }
 
            set_actor_anim(ACTOR_PLAYER, 0, ANIM_Mario1_Walk);
            battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_MAIN] = battleStatus->curSubmenu = battle_menu_submenuIDs[submenuResult - 1];
            for (i = 0; i < ARRAY_COUNT(battleStatus->submenuMoves); i++) {
                battleStatus->submenuMoves[i] = 0;
                battleStatus->submenuIcons[i] = 0;
                battleStatus->submenuStatus[i] = 0;
            }
 
            switch (battleStatus->curSubmenu) {
                case BTL_MENU_TYPE_ITEMS:
                    battleStatus->submenuMoves[0] = BattleMenu_CategoryForSubmenu[BTL_MENU_TYPE_STAR_POWERS]; // ???
                    battleStatus->submenuIcons[0] = ITEM_PARTNER_ATTACK;
                    battleStatus->submenuStatus[0] = 1;
                    for (i = 0; i < ARRAY_COUNT(playerData->invItems); i++) {
                        if (playerData->invItems[i] == ITEM_NONE) {
                            continue;
                        }
                        itemData = &gItemTable[playerData->invItems[i]];
 
                        battleStatus->moveCategory = BTL_MENU_TYPE_ITEMS;
                        battleStatus->moveArgument = playerData->invItems[i];
                        battleStatus->curTargetListFlags = itemData->targetFlags;
                        create_current_pos_target_list(playerActor);
                    }
                    entryIdx = 1;
                    for (i = 0; i < ARRAY_COUNT(playerData->equippedBadges); i++) {
                        if (playerData->equippedBadges[i] != 0) {
                            s32 moveID = gItemTable[playerData->equippedBadges[i]].moveID;
                            moveData = &gMoveTable[moveID];
                            if (moveData->category == BattleMenu_CategoryForSubmenu[battleStatus->curSubmenu]) {
                                s32 cost = moveData->costFP;
                                battleStatus->submenuMoves[entryIdx] = moveID;
                                battleStatus->submenuIcons[entryIdx] = playerData->equippedBadges[i];
                                battleStatus->submenuStatus[entryIdx] = 1;
 
                                cost -= player_team_is_ability_active(playerActor, ABILITY_FLOWER_SAVER);
                                cost -= 2 * player_team_is_ability_active(playerActor, ABILITY_FLOWER_FANATIC);
 
                                if (playerData->curFP < cost) {
                                    battleStatus->submenuStatus[entryIdx] = 0;
                                }
                                entryIdx++;
                            }
                        }
                    }
                    battleStatus->submenuMoveCount = entryIdx;
                    if (entryIdx == 1) {
                        battleStatus->submenuMoveCount = 0;
                    }
                    break;
                case BTL_MENU_TYPE_SMASH:
                    btl_init_menu_hammer();
                    if (battleStatus->submenuMoveCount == 1) {
                        battleStatus->submenuMoveCount = 0;
                    }
                    if (battleStatus->actionCommandMode == AC_MODE_TUTORIAL) {
                        battleStatus->submenuMoveCount = 0;
                    }
                    break;
                case BTL_MENU_TYPE_JUMP:
                    btl_init_menu_boots();
                    if (battleStatus->submenuMoveCount == 1) {
                        battleStatus->submenuMoveCount = 0;
                    }
                    if (battleStatus->actionCommandMode == AC_MODE_TUTORIAL) {
                        battleStatus->submenuMoveCount = 0;
                    }
                    break;
                case BTL_MENU_TYPE_STAR_POWERS:
                    battleStatus->submenuMoves[0] = MOVE_FOCUS;
                    battleStatus->submenuIcons[0] = ITEM_PARTNER_ATTACK;
                    battleStatus->submenuStatus[0] = 1;
                    entryIdx = 1;
                    initialPos = 8;
                    for (i = 0; i < playerData->maxStarPower; i++) {
                        moveData = &gMoveTable[MOVE_REFRESH + i];
                        battleStatus->submenuMoves[entryIdx] = MOVE_REFRESH + i;
                        battleStatus->submenuIcons[entryIdx] = 0;
                        battleStatus->moveCategory = BTL_MENU_TYPE_STAR_POWERS;
                        battleStatus->moveArgument = MOVE_REFRESH + i;
                        battleStatus->curTargetListFlags = moveData->flags;
                        create_current_pos_target_list(playerActor);
                        battleStatus->submenuStatus[entryIdx] = 1;
                        if (playerActor->targetListLength == 0) {
                            battleStatus->submenuStatus[entryIdx] = -2;
                        }
                        if (playerData->starPower / SP_PER_BAR < moveData->costFP) {
                            battleStatus->submenuStatus[entryIdx] = 0;
                        }
                        if (gBattleStatus.flags2 & BS_FLAGS2_NO_TARGET_AVAILABLE) {
                            battleStatus->submenuStatus[entryIdx] = -1;
                        }
                        entryIdx++;
                    }
                    starBeamLevel = playerData->starBeamLevel;
                    if (starBeamLevel == 1) {
                        moveData = &gMoveTable[MOVE_STAR_BEAM];
                        battleStatus->submenuMoves[entryIdx] = MOVE_STAR_BEAM;
                        battleStatus->submenuIcons[entryIdx] = 0;
                        battleStatus->moveCategory = BTL_MENU_TYPE_STAR_POWERS;
                        battleStatus->moveArgument = MOVE_REFRESH + i;
                        battleStatus->curTargetListFlags = moveData->flags;
                        create_current_pos_target_list(playerActor);
                        battleStatus->submenuStatus[entryIdx] = starBeamLevel;
                        if (playerActor->targetListLength == 0) {
                            battleStatus->submenuStatus[entryIdx] = -2;
                        }
                        if (playerData->starPower / SP_PER_BAR < moveData->costFP) {
                            battleStatus->submenuStatus[entryIdx] = 0;
                        }
                        if (gBattleStatus.flags2 & BS_FLAGS2_NO_TARGET_AVAILABLE) {
                            battleStatus->submenuStatus[entryIdx] = -1;
                        }
                        entryIdx++;
                    }
                    if (playerData->starBeamLevel == 2) {
                        moveData = &gMoveTable[MOVE_PEACH_BEAM];
                        battleStatus->submenuMoves[entryIdx] = MOVE_PEACH_BEAM;
                        battleStatus->submenuIcons[entryIdx] = 0;
                        battleStatus->moveCategory = BTL_MENU_TYPE_STAR_POWERS;
                        battleStatus->moveArgument = MOVE_REFRESH + i;
                        battleStatus->curTargetListFlags = moveData->flags;
                        create_current_pos_target_list(playerActor);
                        battleStatus->submenuStatus[entryIdx] = 1;
                        if (playerActor->targetListLength == 0) {
                            battleStatus->submenuStatus[entryIdx] = -2;
                        }
                        if (playerData->starPower / SP_PER_BAR < moveData->costFP) {
                            battleStatus->submenuStatus[entryIdx] = 0;
                        }
                        if (gBattleStatus.flags2 & BS_FLAGS2_NO_TARGET_AVAILABLE) {
                            battleStatus->submenuStatus[entryIdx] = -1;
                        }
                        entryIdx++;
                    }
                    battleStatus->submenuMoveCount = entryIdx;
                    break;
            }
 
            currentSubmenu = battleStatus->curSubmenu;
            if (currentSubmenu == BTL_MENU_TYPE_STAR_POWERS) {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_1;
                btl_state_update_player_menu();
                btl_state_update_player_menu();
                break;
            } else if (currentSubmenu == BTL_MENU_TYPE_STRATEGIES) {
                if (battleStatus->actionCommandMode != AC_MODE_TUTORIAL && !(gBattleStatus.flags1 & BS_FLAGS1_TUTORIAL_BATTLE)) {
                    gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_BUILD_STRATEGIES;
                    btl_state_update_player_menu();
                    btl_state_update_player_menu();
                    break;
                } else {
                    btl_main_menu_destroy();
                    battleStatus->moveCategory = currentSubmenu;
                    battleStatus->moveArgument = 0;
                    battleStatus->selectedMoveID = 0;
                    btl_set_state(BATTLE_STATE_PLAYER_MOVE);
                    break;
                }
            } else {
                if (battleStatus->submenuMoveCount == 0) {
                    if (currentSubmenu != BTL_MENU_TYPE_ITEMS) {
                        gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_10;
                        break;
                    } else {
                        gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_ITEMS_1;
                        btl_state_update_player_menu();
                        btl_state_update_player_menu();
                        break;
                    }
                }
 
                initialPos = 0;
                if (currentSubmenu == BTL_MENU_TYPE_JUMP) {
                    if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_JUMP] < 0) {
                        battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_JUMP] = 0;
                    }
                    initialPos = battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_JUMP];
                }
                if (battleStatus->curSubmenu == BTL_MENU_TYPE_SMASH) {
                    if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_SMASH] < 0) {
                        battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_SMASH] = 0;
                    }
                    initialPos = battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_SMASH];
                }
                if (battleStatus->curSubmenu == BTL_MENU_TYPE_ITEMS) {
                    if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_ITEMS] < 0) {
                        battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_ITEMS] = 0;
                    }
                    initialPos = battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_ITEMS];
                }
 
                for (i = 0; i < battleStatus->submenuMoveCount; i++) {
                    moveData = &gMoveTable[battleStatus->submenuMoves[i]];
                    itemData = &gItemTable[battleStatus->submenuIcons[i]];
                    hudScriptPair = &gItemHudScripts[itemData->hudElemID];
 
                    BattleMenu_Moves_OptionCantUseMessages[i] = 0;
                    if (battleStatus->submenuStatus[i] == 0) {
                        BattleMenu_Moves_OptionCantUseMessages[i] = 0;
                    }
                    if (battleStatus->submenuStatus[i] == -1) {
                        battleStatus->submenuStatus[i] = 0;
                        BattleMenu_Moves_OptionCantUseMessages[i] = BTL_MSG_CANT_SELECT_NOW;
                    }
                    if (battleStatus->submenuStatus[i] == -2) {
                        battleStatus->submenuStatus[i] = 0;
                        BattleMenu_Moves_OptionCantUseMessages[i] = BTL_MSG_CANT_SELECT_NOW;
                    }
                    if (battleStatus->submenuStatus[i] == -3) {
                        battleStatus->submenuStatus[i] = 0;
                        BattleMenu_Moves_OptionCantUseMessages[i] = BTL_MSG_CANT_SELECT_NOW_ALT;
                    }
                    battle_menu_moveOptionIconScripts[i] = hudScriptPair->enabled;
                    if (battleStatus->submenuStatus[i] == 0) {
                        battle_menu_moveOptionIconScripts[i] = hudScriptPair->disabled;
                    }
 
                    battle_menu_moveOptionDisplayCosts[i] = moveData->costFP;
                    battle_menu_moveOptionBPCosts[i] = moveData->costBP;
                    BattleMenu_Moves_OptionSortPriority[i] = 0;
                    battle_menu_moveOptionDisplayCostReductions[i] = 0;
                    battle_menu_moveOptionDisplayCostReductionColors[i] = 0;
 
                    if (player_team_is_ability_active(playerActor, ABILITY_FLOWER_SAVER)) {
                        battle_menu_moveOptionDisplayCostReductions[i] += player_team_is_ability_active(playerActor, ABILITY_FLOWER_SAVER);
                        battle_menu_moveOptionDisplayCostReductionColors[i] = 1;
                    }
                    if (player_team_is_ability_active(playerActor, ABILITY_FLOWER_FANATIC)) {
                        battle_menu_moveOptionDisplayCostReductions[i] += 2 * player_team_is_ability_active(playerActor, ABILITY_FLOWER_FANATIC);
                        battle_menu_moveOptionDisplayCostReductionColors[i] = 2;
                    }
 
                    BattleMenu_Moves_OptionIndices[i] = i;
                    BattleMenu_Moves_OptionEnabled[i] = battleStatus->submenuStatus[i];
                    battle_menu_moveOptionNames[i] = moveData->nameMsg;
                    BattleMenu_Moves_OptionDescMessages[i] = moveData->shortDescMsg;
 
                }
                BattleMenu_UsingSpiritsSubmenu = FALSE;
                D_802AD4A8 = initialPos;
                BattleMenu_Moves_OptionCount = battleStatus->submenuMoveCount;
                func_802A2684();
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_2;
                break;
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_2:
            submenuResult = btl_submenu_moves_update();
            if (submenuResult == -1) {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_7;
            } else if (submenuResult == 0) {
            } else if (submenuResult == 255) {
                func_802A1050();
                D_802ACC60 = 8;
                BattleMenu_SwapDelay = 4;
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_CHOOSE_CATEGORY;
                btl_state_update_player_menu();
                btl_state_update_player_menu();
            } else {
                battleStatus->unk_49 = BattleMenu_Moves_OptionIndices[submenuResult - 1];
                battleStatus->selectedMoveID = battleStatus->submenuMoves[battleStatus->unk_49];
                if (battleStatus->curSubmenu == BTL_MENU_TYPE_JUMP) {
                    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_JUMP] = battle_menu_moveOptionActive;
                }
                if (battleStatus->curSubmenu == BTL_MENU_TYPE_SMASH) {
                    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_SMASH] = battle_menu_moveOptionActive;
                }
                currentSubmenu2 = battleStatus->curSubmenu;
                if (battleStatus->curSubmenu == BTL_MENU_TYPE_ITEMS) {
                    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_ITEMS] = battle_menu_moveOptionActive;
                    if (battleStatus->curSubmenu == currentSubmenu2) {
                        gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_UNKNOWN_1;
                        btl_state_update_player_menu();
                        btl_state_update_player_menu();
                        break;
                    }
                }
                func_802A27D0();
                func_802A1030();
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_MOVE_CHOOSE_TARGET;
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_MOVE_CHOOSE_TARGET:
            submenuResult = btl_submenu_moves_update();
            if ((battleStatus->curButtonsPressed & BUTTON_B) && submenuResult == 0) {
                func_802A2AB8();
                func_802A1098();
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_4;
                break;
            }
            if (btl_main_menu_update() == 0) {
                break;
            }
            battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_PLAYER_MENU_MOVE_TARGET_CANCEL;
            battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_PLAYER_MENU_MOVE_TARGET_CHOSEN;
            battleStatus->selectedMoveID = battleStatus->submenuMoves[battleStatus->unk_49];
            battleStatus->curTargetListFlags = gMoveTable[battleStatus->submenuMoves[battleStatus->unk_49]].flags;
            currentSubmenu = battleStatus->curSubmenu;
            switch (currentSubmenu) {
                case BTL_MENU_TYPE_JUMP:
                    battleStatus->moveCategory = BTL_MENU_TYPE_JUMP;
                    battleStatus->moveArgument = playerData->bootsLevel;
                    btl_set_state(BATTLE_STATE_SELECT_TARGET);
                    break;
                case BTL_MENU_TYPE_SMASH:
                    battleStatus->moveCategory = BTL_MENU_TYPE_SMASH;
                    battleStatus->moveArgument = playerData->hammerLevel;
                    btl_set_state(BATTLE_STATE_SELECT_TARGET);
                    break;
                case BTL_MENU_TYPE_DEFEND:
                    gBattleSubState = battleStatus->acceptTargetMenuSubstate;
                    btl_state_update_player_menu();
                    battleStatus->moveCategory = BTL_MENU_TYPE_DEFEND;
                    btl_set_state(BATTLE_STATE_DEFEND);
                    break;
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_4:
            btl_submenu_moves_update();
            if (btl_main_menu_update() == 0) {
                break;
            }
            gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_2;
            break;
        case BTL_SUBSTATE_PLAYER_MENU_MOVE_TARGET_CANCEL:
            func_802A2AB8();
            func_802A1098();
            gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_4;
            break;
        case BTL_SUBSTATE_PLAYER_MENU_MOVE_TARGET_CHOSEN:
            func_802A27E4();
            btl_main_menu_destroy();
            break;
        case BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_7:
            if (btl_submenu_moves_update() != -1) {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_2;
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_MAIN_SHOW_CANT_SWAP:
            if (gBattleStatus.flags2 & BS_FLAGS2_PARTNER_TURN_USED) {
                btl_show_variable_battle_message(BTL_MSG_CANT_SWITCH, 60, 0);
            } else {
                btl_show_variable_battle_message(BTL_MSG_CANT_MOVE, 60, playerData->curPartner);
            }
            ShowingErrorMessage = TRUE;
            gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_MAIN_AWAIT_CANT_SWAP;
            break;
        case BTL_SUBSTATE_PLAYER_MENU_MAIN_AWAIT_CANT_SWAP:
            if (btl_is_popup_displayed()) {
                break;
            }
            ShowingErrorMessage = FALSE;
            D_802ACC60 = 0;
            BattleMenu_SwapDelay = 4;
            gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_CHOOSE_CATEGORY;
            break;
        case BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_10:
            func_802A1030();
            gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_11;
            break;
        case BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_11:
            submenuResult = btl_main_menu_update();
            if ((battleStatus->curButtonsPressed & BUTTON_B) && submenuResult == 0) {
                func_802A1078();
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_12;
            } else if (submenuResult != 0) {
                battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_13;
                battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_14;
                switch (battleStatus->curSubmenu) {
                    case BTL_MENU_TYPE_JUMP:
                        battleStatus->moveCategory = BTL_MENU_TYPE_JUMP;
                        battleStatus->moveArgument = playerData->bootsLevel;
                        battleStatus->selectedMoveID = playerData->bootsLevel + MOVE_JUMP1;
                        battleStatus->curTargetListFlags = gMoveTable[battleStatus->selectedMoveID].flags;
                        btl_set_state(BATTLE_STATE_SELECT_TARGET);
                        break;
                    case BTL_MENU_TYPE_SMASH:
                        battleStatus->moveCategory = BTL_MENU_TYPE_SMASH;
                        battleStatus->moveArgument = playerData->hammerLevel;
                        battleStatus->selectedMoveID = playerData->hammerLevel + MOVE_HAMMER1;
                        battleStatus->curTargetListFlags = gMoveTable[battleStatus->selectedMoveID].flags;
                        btl_set_state(BATTLE_STATE_SELECT_TARGET);
                        break;
                    default:
                        goto CASE_C; // TODO find better match
                }
            }
            break;
        CASE_C:
        case BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_12:
            if (btl_main_menu_update() == 0) {
                break;
            }
            D_802ACC60 = 8;
            BattleMenu_SwapDelay = 4;
            gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_CHOOSE_CATEGORY;
            break;
        case BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_13:
            func_802A1078();
            gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_12;
            break;
        case BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_14:
            btl_main_menu_destroy();
            break;
        case BTL_SUBSTATE_PLAYER_MENU_UNKNOWN_1:
            if (battleStatus->selectedMoveID == MOVE_DOUBLE_DIP) {
                battleStatus->itemUsesLeft = 2;
            }
            if (battleStatus->selectedMoveID == MOVE_TRIPLE_DIP) {
                battleStatus->itemUsesLeft = 3;
            }
            entryIdx = 0;
            for (i = 0; i < ARRAY_COUNT(playerData->invItems); i++) {
                if (playerData->invItems[i] == ITEM_NONE) {
                    continue;
                }
                itemData = &gItemTable[playerData->invItems[i]];
                hudScriptPair = &gItemHudScripts[itemData->hudElemID];
                if (!(itemData->typeFlags & ITEM_TYPE_FLAG_BATTLE_USABLE)) {
                    continue;
                }
                battleStatus->moveCategory = BTL_MENU_TYPE_ITEMS;
                battleStatus->moveArgument = playerData->invItems[i];
                battleStatus->curTargetListFlags = itemData->targetFlags;
                create_current_pos_target_list(playerActor);
                popup->ptrIcon[entryIdx] = hudScriptPair->enabled;
                popup->userIndex[entryIdx] = playerData->invItems[i];
                popup->enabled[entryIdx] = TRUE;
                popup->nameMsg[entryIdx] = itemData->nameMsg;
                popup->descMsg[entryIdx] = itemData->shortDescMsg;
                if (playerActor->targetListLength == 0) {
                    popup->ptrIcon[entryIdx] = hudScriptPair->disabled;
                    popup->enabled[entryIdx] = 0;
                }
                entryIdx++;
            }
            popup->dipMode = 0;
            popup->titleNumber = 0;
            if (battleStatus->selectedMoveID == MOVE_DOUBLE_DIP) {
                popup->dipMode = 1;
                popup->titleNumber = battleStatus->itemUsesLeft;
            }
            if (battleStatus->selectedMoveID == MOVE_TRIPLE_DIP) {
                popup->dipMode = 2;
                popup->titleNumber = battleStatus->itemUsesLeft;
            }
            if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP] < 0) {
                battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP] = 0;
            }
            popup->popupType = POPUP_MENU_USE_ITEM;
            popup->numEntries = entryIdx;
            initialPos = battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP];
            popup->initialPos = initialPos;
            create_battle_popup_menu(popup);
            func_800F52BC();
            gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_DIPPING_CHOOSE_TARGET;
            break;
        case BTL_SUBSTATE_PLAYER_MENU_DIPPING_CHOOSE_TARGET:
            if (popup->result != POPUP_RESULT_CHOOSING) {
                if (popup->result == POPUP_RESULT_CANCEL) {
                    func_802A2910();
                    battleStatus->selectedMoveID = 0;
                    battleStatus->itemUsesLeft = 0;
                    gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_2;
                    btl_state_update_player_menu();
                    btl_state_update_player_menu();
                } else {
                    battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_PLAYER_MENU_DIPPING_TARGET_CANCEL;
                    battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_PLAYER_MENU_DIPPING_TARGET_CHOSEN;
                    battleStatus->unk_1AA = popup->userIndex[popup->result - 1];
                    battleStatus->moveCategory = BTL_MENU_TYPE_ITEMS;
                    battleStatus->moveArgument = battleStatus->unk_1AA;
                    battleStatus->curTargetListFlags = gItemTable[battleStatus->moveArgument].targetFlags | TARGET_FLAG_PRIMARY_ONLY;
                    battleStatus->curAttackElement = 0;
                    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP] = popup->result - 1;
                    hide_popup_menu();
                    func_802A27D0();
                    func_802A1030();
                    gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_UNKNOWN_3;
                }
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_UNKNOWN_3:
            if ((battleStatus->curButtonsPressed & BUTTON_B) && popup->result == POPUP_RESULT_CHOOSING) {
                func_800F16CC();
                func_802A2C58();
                func_802A1098();
                battleStatus->selectedMoveID = 0;
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_UNKNOWN_4;
            } else {
                btl_submenu_moves_update();
                if (btl_main_menu_update()) {
                    btl_set_state(BATTLE_STATE_SELECT_TARGET);
                }
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_UNKNOWN_4:
            btl_submenu_moves_update();
            if (btl_main_menu_update() != 0) {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_DIPPING_CHOOSE_TARGET;
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_DIPPING_TARGET_CANCEL:
            func_800F16CC();
            func_802A2C58();
            func_802A1098();
            btl_submenu_moves_update();
            gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_UNKNOWN_4;
            break;
        case BTL_SUBSTATE_PLAYER_MENU_DIPPING_TARGET_CHOSEN:
            destroy_popup_menu();
            func_802A27E4();
            btl_main_menu_destroy();
            break;
        case BTL_SUBSTATE_PLAYER_MENU_ITEMS_1:
            entryIdx = 0;
            for (i = 0; i < ARRAY_COUNT(playerData->invItems); i++) {
                if (playerData->invItems[i] == ITEM_NONE) {
                    continue;
                }
                itemData = &gItemTable[playerData->invItems[i]];
                hudScriptPair = &gItemHudScripts[itemData->hudElemID];
                if (!(itemData->typeFlags & ITEM_TYPE_FLAG_BATTLE_USABLE)) {
                    continue;
                }
                battleStatus->moveCategory = BTL_MENU_TYPE_ITEMS;
                battleStatus->moveArgument = playerData->invItems[i];
                battleStatus->curTargetListFlags = itemData->targetFlags;
                create_current_pos_target_list(playerActor);
                popup->ptrIcon[entryIdx] = hudScriptPair->enabled;
 
                popup->userIndex[entryIdx] = playerData->invItems[i];
                popup->enabled[entryIdx] = 1;
                popup->nameMsg[entryIdx] = itemData->nameMsg;
                popup->descMsg[entryIdx] = itemData->shortDescMsg;
                if (playerActor->targetListLength == 0) {
                    popup->ptrIcon[entryIdx] = hudScriptPair->disabled;
                    popup->enabled[entryIdx] = 0;
                }
                entryIdx++;
            }
            if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP] < 0) {
                battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP] = 0;
            }
            initialPos = battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP];
            popup->popupType = POPUP_MENU_USE_ITEM;
            popup->numEntries = entryIdx;
            popup->dipMode = 0;
            popup->titleNumber = 0;
            popup->initialPos = initialPos;
            create_battle_popup_menu(popup);
            func_800F52BC();
            gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_ITEMS_2;
            break;
        case BTL_SUBSTATE_PLAYER_MENU_ITEMS_2:
            if (popup->result != POPUP_RESULT_CHOOSING) {
                if (popup->result == POPUP_RESULT_CANCEL) {
                    func_802A1050();
                    D_802ACC60 = 8;
                    BattleMenu_SwapDelay = 4;
                    gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_CHOOSE_CATEGORY;
                    btl_state_update_player_menu();
                    btl_state_update_player_menu();
                } else {
                    battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_PLAYER_MENU_ITEMS_5;
                    battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_PLAYER_MENU_ITEMS_6;
                    battleStatus->unk_1AA = popup->userIndex[popup->result - 1];
                    battleStatus->moveCategory = BTL_MENU_TYPE_ITEMS;
                    battleStatus->moveArgument = battleStatus->unk_1AA;
                    battleStatus->selectedMoveID = MOVE_ITEMS;
                    battleStatus->curTargetListFlags = gItemTable[battleStatus->moveArgument].targetFlags | TARGET_FLAG_PRIMARY_ONLY;
                    battleStatus->curAttackElement = 0;
                    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP] = popup->result - 1;
                    hide_popup_menu();
                    func_802A1030();
                    gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_ITEMS_3;
                }
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_ITEMS_3:
            if ((battleStatus->curButtonsPressed & BUTTON_B) && popup->result == POPUP_RESULT_CHOOSING) {
                func_800F16CC();
                func_802A1098();
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_ITEMS_4;
            } else {
                if (btl_main_menu_update() != 0) {
                    btl_set_state(BATTLE_STATE_SELECT_TARGET);
                }
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_ITEMS_4:
            if (btl_main_menu_update() != 0) {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_ITEMS_2;
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_ITEMS_5:
            func_800F16CC();
            func_802A1098();
            gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_ITEMS_4;
            break;
        case BTL_SUBSTATE_PLAYER_MENU_ITEMS_6:
            destroy_popup_menu();
            btl_main_menu_destroy();
            break;
        case BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_1:
            for (i = 0; i < battleStatus->submenuMoveCount; i++) {
                moveData = &gMoveTable[battleStatus->submenuMoves[i]];
                BattleMenu_Moves_OptionCantUseMessages[i] = 0;
 
                if (battleStatus->submenuStatus[i] == 0) {
                    BattleMenu_Moves_OptionCantUseMessages[i] = 0;
                }
 
                if (battleStatus->submenuStatus[i] == -1) {
                    battleStatus->submenuStatus[i] = 0;
                    BattleMenu_Moves_OptionCantUseMessages[i] = BTL_MSG_CANT_SELECT_NOW;
                }
                if (battleStatus->submenuStatus[i] == -2) {
                    battleStatus->submenuStatus[i] = 0;
                    BattleMenu_Moves_OptionCantUseMessages[i] = BTL_MSG_CANT_SELECT_NOW;
                }
                if (!(battleStatus->enabledStarPowersFlags & (1 << i))) {
                    battleStatus->submenuStatus[i] = 0;
                    BattleMenu_Moves_OptionCantUseMessages[i] = BTL_MSG_CANT_SELECT_NOW;
                }
 
                battle_menu_moveOptionIconScripts[i] = battle_menu_StarPowerMovesHudScripts[2 * STAR_POWER_INDEX(battleStatus->submenuMoves[i]) + 0];
                if (battleStatus->submenuStatus[i] == 0) {
                    battle_menu_moveOptionIconScripts[i] = battle_menu_StarPowerMovesHudScripts[2 * STAR_POWER_INDEX(battleStatus->submenuMoves[i]) + 1];
                }
                battle_menu_moveOptionDisplayCosts[i] = moveData->costFP;
                battle_menu_moveOptionBPCosts[i] = moveData->costBP;
                BattleMenu_Moves_OptionSortPriority[i] = 0;
                BattleMenu_Moves_OptionIndices[i] = i;
                BattleMenu_Moves_OptionEnabled[i] = battleStatus->submenuStatus[i];
                battle_menu_moveOptionNames[i] = moveData->nameMsg;
                BattleMenu_Moves_OptionDescMessages[i] = moveData->shortDescMsg;
                battle_menu_moveOptionDisplayCostReductions[i] = 0;
                battle_menu_moveOptionDisplayCostReductionColors[i] = 0;
            }
            if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_STAR_POWER] < 0) {
                battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_STAR_POWER] = 0;
            }
            initialPos = battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_STAR_POWER];
            BattleMenu_Moves_OptionCount = battleStatus->submenuMoveCount;
            D_802AD4A8 = initialPos;
            BattleMenu_UsingSpiritsSubmenu = TRUE;
            func_802A2684();
            gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_2;
            break;
        case BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_2:
            submenuResult = btl_submenu_moves_update();
            if (submenuResult == -1) {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_7;
            } else if (submenuResult == 0) {
            } else if (submenuResult == 255) {
                func_802A1050();
                D_802ACC60 = 8;
                BattleMenu_SwapDelay = 4;
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_CHOOSE_CATEGORY;
                btl_state_update_player_menu();
                btl_state_update_player_menu();
            } else {
                battleStatus->unk_49 = BattleMenu_Moves_OptionIndices[submenuResult - 1];
                battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_STAR_POWER] = battle_menu_moveOptionActive;
                func_802A27D0();
                func_802A1030();
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_3;
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_3:
            submenuResult = btl_submenu_moves_update();
            if ((battleStatus->curButtonsPressed & BUTTON_B) && submenuResult == 0) {
                func_802A2AB8();
                func_802A1098();
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_4;
            } else if (btl_main_menu_update() != 0) {
                battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_5;
                battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_6;
                battleStatus->moveCategory = BTL_MENU_TYPE_STAR_POWERS;
                battleStatus->selectedMoveID = battleStatus->submenuMoves[battleStatus->unk_49];
                battleStatus->curTargetListFlags = gMoveTable[battleStatus->submenuMoves[battleStatus->unk_49]].flags;
                battleStatus->moveArgument = battleStatus->unk_49;
                if (playerData->starBeamLevel == 2 && battleStatus->moveArgument == 8) {
                    battleStatus->moveArgument++;
                }
                btl_set_state(BATTLE_STATE_SELECT_TARGET);
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_4:
            btl_submenu_moves_update();
            if (btl_main_menu_update() != 0) {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_2;
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_5:
            func_802A2AB8();
            func_802A1098();
            gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_4;
            break;
        case BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_6:
            func_802A27E4();
            btl_main_menu_destroy();
            break;
        case BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_7:
            if (btl_submenu_moves_update() != -1) {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_2;
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_DIPPING_1:
            if (!can_switch_to_player()) {
                battleStatus->itemUsesLeft = 1;
                btl_set_state(BATTLE_STATE_END_PLAYER_TURN);
            } else {
                entryIdx = 0;
                for (i = 0; i < ARRAY_COUNT(playerData->invItems); i++) {
                    if (playerData->invItems[i] == ITEM_NONE) {
                        continue;
                    }
                    itemData = &gItemTable[playerData->invItems[i]];
                    hudScriptPair = &gItemHudScripts[itemData->hudElemID];
                    if (!(itemData->typeFlags & ITEM_TYPE_FLAG_BATTLE_USABLE)) {
                        continue;
                    }
 
                    battleStatus->moveCategory = BTL_MENU_TYPE_ITEMS;
                    battleStatus->moveArgument = playerData->invItems[i];
                    battleStatus->curTargetListFlags = itemData->targetFlags;
                    create_current_pos_target_list(playerActor);
                    popup->ptrIcon[entryIdx] = hudScriptPair->enabled;
                    popup->userIndex[entryIdx] = playerData->invItems[i];
                    popup->enabled[entryIdx] = TRUE;
                    popup->nameMsg[entryIdx] = itemData->nameMsg;
                    popup->descMsg[entryIdx] = itemData->shortDescMsg;
                    if (playerActor->targetListLength == 0) {
                        popup->ptrIcon[entryIdx] = hudScriptPair->disabled;
                        popup->enabled[entryIdx] = FALSE;
                    }
                    entryIdx++;
                }
                if (entryIdx == 0) {
                    battleStatus->itemUsesLeft = 1;
                    btl_set_state(BATTLE_STATE_END_PLAYER_TURN);
                } else {
                    popup->popupType = POPUP_MENU_USE_ITEM;
                    if (battleStatus->selectedMoveID == MOVE_DOUBLE_DIP) {
                        popup->popupType += POPUP_MENU_DOUBLE_DIP;
                        popup->dipMode = 1;
                        popup->titleNumber = battleStatus->itemUsesLeft;
                    }
                    if (battleStatus->selectedMoveID == MOVE_TRIPLE_DIP) {
                        popup->popupType += POPUP_MENU_TRIPLE_DIP;
                        popup->dipMode = 2;
                        popup->titleNumber = battleStatus->itemUsesLeft;
                    }
                    if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP] < 0) {
                        battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP] = 0;
                    }
                    popup->numEntries = entryIdx;
                    initialPos = battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP];
                    popup->initialPos = initialPos;
                    create_battle_popup_menu(popup);
                    func_800F52BC();
                    gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_DIPPING_2;
                }
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_DIPPING_2:
            if (popup->result != POPUP_RESULT_CHOOSING) {
                if (popup->result == POPUP_RESULT_CANCEL) {
                    battleStatus->itemUsesLeft = 1;
                    btl_set_state(BATTLE_STATE_END_PLAYER_TURN);
                } else {
                    battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_PLAYER_MENU_DIPPING_5;
                    battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_PLAYER_MENU_DIPPING_6;
                    battleStatus->unk_1AA = popup->userIndex[popup->result - 1];
                    battleStatus->moveCategory = BTL_MENU_TYPE_ITEMS;
                    battleStatus->moveArgument = battleStatus->unk_1AA;
                    battleStatus->curTargetListFlags = gItemTable[battleStatus->moveArgument].targetFlags | TARGET_FLAG_PRIMARY_ONLY;
                    battleStatus->curAttackElement = 0;
                    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_DIP] = popup->result - 1;
                    hide_popup_menu();
                    D_802ACC60 = 5;
                    gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_DIPPING_3;
                }
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_DIPPING_3:
            if (D_802ACC60 != 0) {
                D_802ACC60--;
            } else {
                btl_set_state(BATTLE_STATE_SELECT_TARGET);
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_DIPPING_4:
            if (D_802ACC60 != 0) {
                D_802ACC60--;
            } else {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_DIPPING_2;
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_DIPPING_5:
            func_800F16CC();
            D_802ACC60 = 5;
            gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_DIPPING_4;
            break;
        case BTL_SUBSTATE_PLAYER_MENU_DIPPING_6:
            destroy_popup_menu();
            break;
        case BTL_SUBSTATE_PLAYER_MENU_BERSERKER_CHOOSE:
            if (playerData->bootsLevel >= 0) {
                battleStatus->curTargetListFlags = gMoveTable[MOVE_BERSERKER_JUMP].flags;
                create_current_pos_target_list(playerActor);
                jumpTargetCount = playerActor->targetListLength;
            } else {
                jumpTargetCount = 0;
            }
 
            if (playerData->hammerLevel >= 0) {
                battleStatus->curTargetListFlags = gMoveTable[MOVE_BERSERKER_HAMMER].flags;
                create_current_pos_target_list(playerActor);
                hammerTargetCount = playerActor->targetListLength;
            } else {
                hammerTargetCount = 0;
            }
 
            if (jumpTargetCount <= 0 && hammerTargetCount <= 0) {
                battleStatus->moveCategory = BTL_MENU_TYPE_DO_NOTHING;
                battleStatus->waitForState = BATTLE_STATE_0;
                btl_set_state(BATTLE_STATE_END_PLAYER_TURN);
            } else {
                jumpChance = 50;
                if (jumpTargetCount <= 0) {
                    jumpChance = 0;
                }
                if (hammerTargetCount <= 0) {
                    jumpChance = 101;
                }
                if (rand_int(100) < jumpChance) {
                    battleStatus->selectedMoveID = MOVE_BERSERKER_JUMP;
                    battleStatus->moveCategory = BTL_MENU_TYPE_JUMP;
                    battleStatus->curTargetListFlags = gMoveTable[MOVE_BERSERKER_JUMP].flags;
                    battleStatus->moveArgument = playerData->bootsLevel;
                    create_current_pos_target_list(playerActor);
                } else {
                    battleStatus->selectedMoveID = MOVE_BERSERKER_HAMMER;
                    battleStatus->moveCategory = BTL_MENU_TYPE_SMASH;
                    battleStatus->curTargetListFlags = gMoveTable[MOVE_BERSERKER_HAMMER].flags;
                    battleStatus->moveArgument = playerData->hammerLevel;
                    create_current_pos_target_list(playerActor);
                }
                btl_set_state(BATTLE_STATE_PLAYER_MOVE);
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_BUILD_STRATEGIES:
            entryIdx = 0;
            btl_check_can_change_partner();
 
            // add 'Change Member' command
            if (battleStatus->changePartnerAllowed >= 0) {
                D_802AD678[entryIdx] = BTL_MENU_TYPE_CHANGE_PARTNER;
                D_802AD658[entryIdx] = BattleMenu_LeftJustMessages[BTL_MENU_TYPE_CHANGE_PARTNER];
                D_802AD640[entryIdx] = battle_menu_PartnerHudScripts[playerData->curPartner];
                D_802AD690[entryIdx] = 1;
                D_802AD6C0[entryIdx] = MSG_Menus_Action_ChangePartner;
                if (battleStatus->changePartnerAllowed <= 0) {
                    D_802AD640[entryIdx] = battle_menu_DisabledPartnerHudScripts[playerData->curPartner];
                    D_802AD690[entryIdx] = 0;
                    D_802AD6A8[entryIdx] = 0;
                }
                entryIdx++;
            }
 
            // add 'Do Nothing' command
            D_802AD640[entryIdx] = battle_menu_DoNothingHudScripts.enabled;
            D_802AD678[entryIdx] = BTL_MENU_TYPE_DO_NOTHING;
            D_802AD690[entryIdx] = 1;
            D_802AD658[entryIdx] = BattleMenu_LeftJustMessages[BTL_MENU_TYPE_DO_NOTHING];
            D_802AD6C0[entryIdx] = MSG_Menus_Action_DoNothing;
            entryIdx++;
 
            // add 'Run Away' command
            D_802AD640[entryIdx] = battle_menu_FleeHudScripts.enabled;
            D_802AD678[entryIdx] = BTL_MENU_TYPE_RUN_AWAY;
            D_802AD690[entryIdx] = 1;
            D_802AD658[entryIdx] = BattleMenu_LeftJustMessages[BTL_MENU_TYPE_RUN_AWAY];
            D_802AD6C0[entryIdx] = MSG_Menus_Action_RunAway;
            if (!(gBattleStatus.flags2 & BS_FLAGS2_CAN_FLEE)) {
                D_802AD640[entryIdx] = battle_menu_FleeHudScripts.disabled;
                D_802AD690[entryIdx] = 0;
                D_802AD6A8[entryIdx] = 1;
            }
            entryIdx++;
 
            if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_STRATEGY] < 0) {
                battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_STRATEGY] = 0;
            }
            initialPos = battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_STRATEGY];
            D_802AD66C = entryIdx;
            StratsMenuLastPos = initialPos;
            func_802A45D8();
            gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_2;
            break;
        case BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_2:
            submenuResult = btl_update_strats_menu();
            if (submenuResult == -1) {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_8;
            } else if (submenuResult == 0) {
            } else if (submenuResult == 255) {
                func_802A1050();
                D_802ACC60 = 8;
                BattleMenu_SwapDelay = 4;
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_CHOOSE_CATEGORY;
                btl_state_update_player_menu();
                btl_state_update_player_menu();
            } else {
                battleStatus->curSubmenu = D_802AD678[submenuResult - 1];
                battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_STRATEGY] = submenuResult - 1;
                if (battleStatus->curSubmenu == 5) { // change partner
                    gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_1;
                    btl_state_update_player_menu();
                    btl_state_update_player_menu();
                } else {
                    func_802A4718();
                    func_802A1030();
                    gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_3;
                }
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_3:
            submenuResult = btl_update_strats_menu();
            if ((battleStatus->curButtonsPressed & BUTTON_B) && submenuResult == 0) {
                func_802A48FC();
                func_802A1098();
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_4;
            } else if (btl_main_menu_update() != 0) {
                battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_5;
                battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_6;
                switch (battleStatus->curSubmenu) {
                    case 3:
                        gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_6;
                        btl_state_update_player_menu();
                        battleStatus->moveCategory = BTL_MENU_TYPE_RUN_AWAY;
                        battleStatus->selectedMoveID = MOVE_UNUSED_39;
                        btl_set_state(BATTLE_STATE_RUN_AWAY);
                        break;
                    case 9:
                        battleStatus->hustleTurns = 0;
                        gBattleStatus.flags1 &= ~BS_FLAGS1_HUSTLED;
                        gBattleSubState = battleStatus->acceptTargetMenuSubstate;
                        btl_state_update_player_menu();
                        btl_set_state(BATTLE_STATE_END_PLAYER_TURN);
                        break;
                    case 4:
                        gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_6;
                        btl_state_update_player_menu();
                        battleStatus->selectedMoveID = MOVE_UNUSED_DEFEND_PLUS;
                        battleStatus->moveCategory = BTL_MENU_TYPE_DEFEND;
                        btl_set_state(BATTLE_STATE_DEFEND);
                        break;
                    case 10:
                        gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_6;
                        btl_state_update_player_menu();
                        btl_set_state(BATTLE_STATE_SWITCH_TO_PARTNER);
                        break;
                }
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_4:
            btl_update_strats_menu();
            if (btl_main_menu_update() != 0) {
                D_802ACC60 = 8;
                BattleMenu_SwapDelay = 4;
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_CHOOSE_CATEGORY;
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_5:
            func_802A48FC();
            func_802A1098();
            gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_4;
            break;
        case BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_6:
            func_802A472C();
            btl_main_menu_destroy();
            break;
        case BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_8:
            if (btl_update_strats_menu() != -1) {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_2;
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_1:
            entryIdx = 0;
            for (i = 1; i < ARRAY_COUNT(playerData->partners); i++) {
                s32 partnerId = PartnerIDFromMenuIndex[i];
                if (playerData->partners[partnerId].enabled) {
                    prop = &gPartnerPopupProperties[partnerId];
                    popup->ptrIcon[entryIdx] = battle_menu_PartnerHudScripts[partnerId];
                    popup->userIndex[entryIdx] = partnerId;
                    popup->enabled[entryIdx] = 1;
                    popup->nameMsg[entryIdx] = prop->nameMsg;
                    popup->descMsg[entryIdx] = prop->battleDescMsg;
                    popup->value[entryIdx] = playerData->partners[partnerId].level;
                    if (playerData->curPartner == partnerId) {
                        popup->enabled[entryIdx] = 0;
                        popup->ptrIcon[entryIdx] = battle_menu_DisabledPartnerHudScripts[partnerId];
                    }
                    entryIdx++;
                }
            }
            if (battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_PARTNER] < 0) {
                battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_PARTNER] = 0;
            }
            popup->popupType = POPUP_MENU_SWITCH_PARTNER;
            popup->numEntries = entryIdx;
            popup->initialPos = MenuIndexFromPartnerID[playerData->curPartner] - 1;
            popup->dipMode = 0;
            popup->titleNumber = 0;
            create_battle_popup_menu(popup);
            func_800F52BC();
            gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_2;
            break;
        case BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_2:
            if (popup->result == POPUP_RESULT_INVALID) {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_7;
            } else if (popup->result != POPUP_RESULT_CHOOSING) {
                if (popup->result == POPUP_RESULT_CANCEL) {
                    func_802A47E0();
                    gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_2;
                    btl_state_update_player_menu();
                    btl_state_update_player_menu();
                } else {
                    battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_5;
                    battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_6;
                    battleStatus->unk_1AC = popup->userIndex[popup->result - 1];
                    battleStatus->moveCategory = BTL_MENU_TYPE_CHANGE_PARTNER;
                    battleStatus->selectedMoveID = MOVE_UNUSED_37;
                    battleStatus->curTargetListFlags = TARGET_FLAG_2;
                    battleStatus->moveArgument = battleStatus->unk_1AC;
                    battleStatus->lastPlayerMenuSelection[BTL_MENU_IDX_PARTNER] = popup->result - 1;
                    hide_popup_menu();
                    func_802A4718();
                    func_802A1030();
                    gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_3;
                }
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_3:
            if ((battleStatus->curButtonsPressed & BUTTON_B) && popup->result == POPUP_RESULT_CHOOSING) {
                func_800F16CC();
                func_802A4A10();
                func_802A1098();
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_4;
            } else {
                btl_update_strats_menu();
                if (btl_main_menu_update() != 0) {
                    gBattleSubState = battleStatus->acceptTargetMenuSubstate;
                    btl_state_update_player_menu();
                    btl_set_state(BATTLE_STATE_CHANGE_PARTNER);
                }
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_4:
            btl_update_strats_menu();
            if (btl_main_menu_update() != 0) {
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_2;
            }
            break;
        case BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_5:
            func_800F16CC();
            func_802A4A10();
            func_802A1098();
            gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_4;
            break;
        case BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_6:
            destroy_popup_menu();
            func_802A472C();
            btl_main_menu_destroy();
            break;
        case BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_7:
            set_window_update(WIN_BTL_STRATS_MENU, WINDOW_UPDATE_HIDE);
            set_window_update(WIN_BTL_STRATS_TITLE, WINDOW_UPDATE_HIDE);
            if (popup->result != POPUP_RESULT_INVALID) {
                set_window_update(WIN_BTL_STRATS_MENU, WINDOW_UPDATE_9);
                set_window_update(WIN_BTL_STRATS_TITLE, WINDOW_UPDATE_9);
                gBattleSubState = BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_2;
            }
            break;
    }
}

Referenced by btl_state_update_player_menu(), btl_state_update_select_target(), and btl_update().

◆ btl_state_draw_player_menu()

void btl_state_draw_player_menu ( void )

Definition at line 3589 of file btl_states_menus.c.

                                      {
    switch (gBattleSubState) {
        case BTL_SUBSTATE_PLAYER_MENU_CHOOSE_CATEGORY:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_2:
        case BTL_SUBSTATE_PLAYER_MENU_MOVE_CHOOSE_TARGET:
        case BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_4:
        case BTL_SUBSTATE_PLAYER_MENU_MOVE_TARGET_CANCEL:
        case BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_10:
        case BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_11:
        case BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_12:
        case BTL_SUBSTATE_PLAYER_MENU_MAIN_MENU_13:
        case BTL_SUBSTATE_PLAYER_MENU_UNKNOWN_1:
        case BTL_SUBSTATE_PLAYER_MENU_DIPPING_CHOOSE_TARGET:
        case BTL_SUBSTATE_PLAYER_MENU_UNKNOWN_3:
        case BTL_SUBSTATE_PLAYER_MENU_UNKNOWN_4:
        case BTL_SUBSTATE_PLAYER_MENU_DIPPING_TARGET_CANCEL:
        case BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_1:
        case BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_2:
        case BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_3:
        case BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_4:
        case BTL_SUBSTATE_PLAYER_MENU_CHANGE_MEMBER_5:
        case BTL_SUBSTATE_PLAYER_MENU_ITEMS_1:
        case BTL_SUBSTATE_PLAYER_MENU_ITEMS_2:
        case BTL_SUBSTATE_PLAYER_MENU_ITEMS_3:
        case BTL_SUBSTATE_PLAYER_MENU_ITEMS_4:
        case BTL_SUBSTATE_PLAYER_MENU_ITEMS_5:
        case BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_2:
        case BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_3:
        case BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_4:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_5:
        case BTL_SUBSTATE_PLAYER_MENU_STAR_SPIRITS_6:
        case BTL_SUBSTATE_PLAYER_MENU_BUILD_STRATEGIES:
        case BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_2:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_3:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_4:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_5:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_PLAYER_MENU_STRATEGIES_6:
            btl_main_menu_draw();
            break;
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_partner_menu()

void btl_state_update_partner_menu ( void )

Definition at line 3643 of file btl_states_menus.c.

                                         {
    BattleStatus* battleStatus = &gBattleStatus;
    PlayerData* playerData = &gPlayerData;
    Actor* playerActor = battleStatus->playerActor;
    Actor* partnerActor = battleStatus->partnerActor;
    PopupMenu* popupMenu = &D_802ACCD0;
    s32 entryIdx;
    s32 i;
    s32 popupIndex;
    s32 initialPos;
    MoveData* moveData;
    PartnerPopupProperties* popupProps;
 
    if (gBattleSubState == BTL_SUBSTATE_PARTNER_MENU_NONE) {
        battleStatus->moveCategory = BTL_MENU_TYPE_INVALID;
        battleStatus->selectedMoveID = MOVE_NONE;
        battleStatus->curAttackElement = 0;
        if (!can_switch_to_partner()) {
            btl_set_state(BATTLE_STATE_9);
        } else {
            btl_cam_use_preset(BTL_CAM_DEFAULT);
            battleStatus->flags1 |= BS_FLAGS1_MENU_OPEN;
            playerActor->flags &= ~(ACTOR_FLAG_USING_IDLE_ANIM | ACTOR_FLAG_SHOW_STATUS_ICONS);
            partnerActor->flags &= ~(ACTOR_FLAG_USING_IDLE_ANIM | ACTOR_FLAG_SHOW_STATUS_ICONS);
            if (battleStatus->flags1 & BS_FLAGS1_PLAYER_IN_BACK) {
                gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_INIT_MENU;
            } else {
                gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_12D;
                partnerActor->state.curPos.x = partnerActor->homePos.x;
                partnerActor->state.curPos.z = partnerActor->homePos.z;
                partnerActor->state.goalPos.x = playerActor->homePos.x;
                partnerActor->state.goalPos.z = playerActor->homePos.z;
                partnerActor->state.moveTime = 4;
                partnerActor->state.angle = 0.0f;
            }
        }
    }
    if (gBattleSubState == BTL_SUBSTATE_PARTNER_MENU_12D) {
        if (partnerActor->state.moveTime != 0) {
            partnerActor->curPos.x += (partnerActor->state.goalPos.x - partnerActor->curPos.x) / partnerActor->state.moveTime;
            partnerActor->curPos.z += (partnerActor->state.goalPos.z - partnerActor->curPos.z) / partnerActor->state.moveTime;
            playerActor->curPos.x += (partnerActor->state.curPos.x - playerActor->curPos.x) / partnerActor->state.moveTime;
            playerActor->curPos.z += (partnerActor->state.curPos.z - playerActor->curPos.z) / partnerActor->state.moveTime;
        }
        partnerActor->curPos.z += sin_rad(DEG_TO_RAD(partnerActor->state.angle)) * 16.0f;
        partnerActor->yaw = clamp_angle(-partnerActor->state.angle);
        playerActor->curPos.z -= sin_rad(DEG_TO_RAD(partnerActor->state.angle)) * 16.0f;
        playerActor->yaw = clamp_angle(-partnerActor->state.angle);
        partnerActor->state.angle += 90.0f;
        if (partnerActor->state.moveTime != 0) {
            partnerActor->state.moveTime--;
        } else {
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_INIT_MENU;
            partnerActor->curPos.x = partnerActor->state.goalPos.x;
            partnerActor->curPos.z = partnerActor->state.goalPos.z;
            playerActor->curPos.x = partnerActor->state.curPos.x;
            playerActor->curPos.z = partnerActor->state.curPos.z;
            partnerActor->homePos.x = partnerActor->curPos.x;
            partnerActor->homePos.z = partnerActor->curPos.z;
            playerActor->homePos.x = playerActor->curPos.x;
            playerActor->homePos.z = playerActor->curPos.z;
            gBattleStatus.flags1 |= BS_FLAGS1_PLAYER_IN_BACK;
        }
    }
    switch (gBattleSubState) {
        case BTL_SUBSTATE_PARTNER_MENU_INIT_MENU:
            partnerActor->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            partnerActor->flags &= ~ACTOR_FLAG_USING_IDLE_ANIM;
            playerActor->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
            playerActor->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            btl_init_menu_items();
            btl_check_can_change_partner();
            entryIdx = 0;
            initialPos = 1;
            if (battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_MAIN] < 0) {
                battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_MAIN] = BTL_MENU_TYPE_ABILITY;
            }
            btl_init_menu_partner();
            btl_check_can_change_partner();
 
            // strategies menu category
            battle_menu_submenuIDs[entryIdx] = BTL_MENU_TYPE_STRATEGIES;
            BattleMenu_OptionEnabled[entryIdx] = TRUE;
            battle_menu_isMessageDisabled[entryIdx] = 0;
            BattleMenu_HudScripts[entryIdx] = battle_menu_StrategiesHudScript.enabled;
            BattleMenu_TitleMessages[entryIdx] = BattleMenu_CenteredMessages[BTL_MENU_TYPE_STRATEGIES];
            if (!(battleStatus->enabledMenusFlags & BTL_MENU_ENABLED_STRATEGIES)) {
                BattleMenu_OptionEnabled[entryIdx] = FALSE;
                battle_menu_isMessageDisabled[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
                BattleMenu_HudScripts[entryIdx] = battle_menu_StrategiesHudScript.disabled;
            }
            if (battleStatus->lastPartnerMenuSelection[entryIdx] == BTL_MENU_TYPE_STRATEGIES) {
                initialPos = entryIdx;
            }
            entryIdx++;
 
            // abilities menu category
            BattleMenu_HudScripts[entryIdx] = battle_menu_PartnerMoveHudScripts[playerData->curPartner][0];
            battle_menu_submenuIDs[entryIdx] = BTL_MENU_TYPE_ABILITY;
            BattleMenu_OptionEnabled[entryIdx] = TRUE;
            BattleMenu_TitleMessages[entryIdx] = BattleMenu_CenteredMessages[BTL_MENU_TYPE_ABILITY];
            if (battleStatus->menuStatus[3] <= 0) {
                BattleMenu_HudScripts[entryIdx] = battle_menu_PartnerMoveHudScripts[playerData->curPartner][1];
                BattleMenu_OptionEnabled[entryIdx] = FALSE;
                battle_menu_isMessageDisabled[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
            }
            if (!(battleStatus->enabledMenusFlags & BTL_MENU_ENABLED_ABILITIES)) {
                BattleMenu_HudScripts[entryIdx] = battle_menu_PartnerMoveHudScripts[playerData->curPartner][1];
                BattleMenu_OptionEnabled[entryIdx] = FALSE;
                battle_menu_isMessageDisabled[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
            }
            if (battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_MAIN] == BTL_MENU_TYPE_ABILITY) {
                initialPos = entryIdx;
            }
            entryIdx++;
 
            // focus menu category
            if (playerData->maxStarPower != 0 && is_ability_active(ABILITY_GROUP_FOCUS)) {
                battle_menu_submenuIDs[entryIdx] = BTL_MENU_TYPE_PARTNER_FOCUS;
                BattleMenu_OptionEnabled[entryIdx] = TRUE;
                battle_menu_isMessageDisabled[entryIdx] = 0;
                BattleMenu_HudScripts[entryIdx] = battle_menu_StarPowerHudScripts.enabled;
                BattleMenu_TitleMessages[entryIdx] = BattleMenu_CenteredMessages[BTL_MENU_TYPE_PARTNER_FOCUS];
                if (!(battleStatus->enabledMenusFlags & BTL_MENU_ENABLED_PARTNER_FOCUS)) {
                    BattleMenu_OptionEnabled[entryIdx] = FALSE;
                    battle_menu_isMessageDisabled[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
                    BattleMenu_HudScripts[entryIdx] = battle_menu_StarPowerHudScripts.disabled;
                }
                if (battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_MAIN] == BTL_MENU_TYPE_PARTNER_FOCUS) {
                    initialPos = entryIdx;
                }
                entryIdx++;
            }
 
            BattleMenu_NumOptions = entryIdx;
            D_802AD0A8 = 1;
            D_802AD0B0 = initialPos;
            D_802AD100 = 2 - initialPos;
            if (can_switch_to_player()) {
                BattleMenu_ShowSwapIcons = TRUE;
            } else {
                BattleMenu_ShowSwapIcons = FALSE;
            }
            btl_main_menu_init();
            D_802ACC60 = 8;
            BattleMenu_SwapDelay = 0;
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_1;
            return;
        case BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_1:
            set_actor_anim(ACTOR_PARTNER, 0, BattleMenu_PartnerThinkAnims[playerData->curPartner]);
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_2;
        case BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_2:
            entryIdx = btl_main_menu_update();
 
            if (BattleMenu_SwapDelay != 0) {
                BattleMenu_SwapDelay--;
            } else if (!(gBattleStatus.flags1 & BS_FLAGS1_TUTORIAL_BATTLE) && (gGameStatusPtr->pressedButtons[0] & BUTTON_Z)) {
                if (can_switch_to_player()) {
                    sfx_play_sound(SOUND_PARTNER_SWAP_BATTLE_POS);
                    battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_MAIN] = battle_menu_submenuIDs[BattleMenu_CurPos + BattleMenu_HomePos];
                    btl_main_menu_destroy();
                    btl_set_state(BATTLE_STATE_SWITCH_TO_PLAYER);
                } else {
                    sfx_play_sound(SOUND_MENU_ERROR);
                    gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_MAIN_SHOW_CANT_SWAP;
                }
                break;
            }
 
            if (D_802ACC60 != 0) {
                D_802ACC60--;
            } else if (entryIdx != 0) {
                set_actor_anim(ACTOR_PARTNER, 0, BattleMenu_PartnerIdleAnims[playerData->curPartner]);
                battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_MAIN] = battleStatus->curPartnerSubmenu = battle_menu_submenuIDs[entryIdx - 1];
                if (battleStatus->curPartnerSubmenu == 7) {
                    gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_1;
                    btl_state_update_partner_menu();
                    btl_state_update_partner_menu();
                } else if (battleStatus->curPartnerSubmenu == 6) {
                    gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_ABILITIES_1;
                    btl_state_update_partner_menu();
                    btl_state_update_partner_menu();
                } else if (battleStatus->curPartnerSubmenu == 8) {
                    gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_FOCUS_1;
                    btl_state_update_partner_menu();
                    btl_state_update_partner_menu();
                } else if (battleStatus->curPartnerSubmenu == 2) {
                    gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_ITEMS_1;
                    btl_state_update_partner_menu();
                    btl_state_update_partner_menu();
                } else if (battleStatus->curPartnerSubmenu == 5) {
                    gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_1;
                    btl_state_update_partner_menu();
                    btl_state_update_partner_menu();
                } else {
                    battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_5;
                    battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_6;
                    func_802A1030();
                    gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_3;
                }
            }
            break;
    case BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_3:
        entryIdx = btl_main_menu_update();
        if ((battleStatus->curButtonsPressed & BUTTON_B) && entryIdx == 0) {
            func_802A1078();
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_4;
            return;
        }
        if (entryIdx != 0) {
            battleStatus->moveCategory = BTL_MENU_TYPE_STAR_POWERS;
            battleStatus->selectedMoveID = MOVE_FOCUS;
            battleStatus->moveArgument = 0;
            battleStatus->curTargetListFlags = gMoveTable[MOVE_FOCUS].flags;
            btl_set_state(BATTLE_STATE_SELECT_TARGET);
            return;
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_4:
        if (btl_main_menu_update() != 0) {
            D_802ACC60 = 8;
            BattleMenu_SwapDelay = 4;
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_1;
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_5:
        func_802A1078();
        gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_4;
        break;
    case BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_6:
        btl_main_menu_destroy();
        break;
    case BTL_SUBSTATE_PARTNER_MENU_MAIN_SHOW_CANT_SWAP:
        if (can_switch_to_player() == 0) {
            btl_show_variable_battle_message(BTL_MSG_CANT_MOVE, 60, 0);
        } else {
            btl_show_variable_battle_message(BTL_MSG_CANT_SWITCH, 60, 0);
        }
        ShowingErrorMessage = TRUE;
        gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_MAIN_AWAIT_CANT_SWAP;
        break;
    case BTL_SUBSTATE_PARTNER_MENU_MAIN_AWAIT_CANT_SWAP:
        if (btl_is_popup_displayed()) {
            break;
        }
        D_802ACC60 = 0;
        ShowingErrorMessage = FALSE;
        BattleMenu_SwapDelay = 4;
        gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_1;
        break;
    case BTL_SUBSTATE_PARTNER_MENU_ABILITIES_1:
        for (i = 0; i < battleStatus->submenuMoveCount; i++) {
            moveData = &gMoveTable[battleStatus->submenuMoves[i]];
 
            BattleMenu_Moves_OptionCantUseMessages[i] = 0;
            if (battleStatus->submenuStatus[i] == 0) {
                BattleMenu_Moves_OptionCantUseMessages[i] = 0;
            }
            if (battleStatus->submenuStatus[i] == -1) {
                battleStatus->submenuStatus[i] = 0;
                BattleMenu_Moves_OptionCantUseMessages[i] = BTL_MSG_CANT_SELECT_NOW;
            }
            if (battleStatus->submenuStatus[i] == -2) {
                battleStatus->submenuStatus[i] = 0;
                BattleMenu_Moves_OptionCantUseMessages[i] = BTL_MSG_CANT_SELECT_NOW;
            }
            battle_menu_moveOptionIconScripts[i] = battle_menu_PartnerMoveHudScripts[playerData->curPartner][2 * i + 2];
            if (battleStatus->submenuStatus[i] == 0) {
                battle_menu_moveOptionIconScripts[i] = battle_menu_PartnerMoveHudScripts[playerData->curPartner][2 * i + 3];
            }
            BattleMenu_Moves_OptionIndices[i] = battleStatus->submenuMoves[i];
            BattleMenu_Moves_OptionEnabled[i] = battleStatus->submenuStatus[i];
            battle_menu_moveOptionNames[i] = moveData->nameMsg;
            BattleMenu_Moves_OptionDescMessages[i] = moveData->shortDescMsg;
            battle_menu_moveOptionDisplayCosts[i] = moveData->costFP;
            battle_menu_moveOptionBPCosts[i] = moveData->costBP;
            BattleMenu_Moves_OptionSortPriority[i] = i;
 
            battle_menu_moveOptionDisplayCostReductions[i] = 0;
            battle_menu_moveOptionDisplayCostReductionColors[i] = 0;
            if (player_team_is_ability_active(playerActor, ABILITY_FLOWER_SAVER)) {
                battle_menu_moveOptionDisplayCostReductions[i] += player_team_is_ability_active(playerActor, ABILITY_FLOWER_SAVER);
                battle_menu_moveOptionDisplayCostReductionColors[i] = 1;
            }
            if (player_team_is_ability_active(playerActor, ABILITY_FLOWER_FANATIC)) {
                battle_menu_moveOptionDisplayCostReductions[i] += player_team_is_ability_active(playerActor, ABILITY_FLOWER_FANATIC) * 2;
                battle_menu_moveOptionDisplayCostReductionColors[i] = 2;
            }
        }
        if (battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_ABILITY] < 0) {
            battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_ABILITY] = 0;
        }
        BattleMenu_UsingSpiritsSubmenu = FALSE;
        BattleMenu_Moves_OptionCount = battleStatus->submenuMoveCount;
        initialPos = battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_ABILITY];
        D_802AD4A8 = initialPos;
        func_802A2684();
        gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_ABILITIES_2;
        break;
    case BTL_SUBSTATE_PARTNER_MENU_ABILITIES_2:
        entryIdx = btl_submenu_moves_update();
        if (entryIdx == -1) {
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_ABILITIES_7;
        } else if (entryIdx  != 0) {
            if (entryIdx == 255) {
                func_802A1050();
                D_802ACC60 = 8;
                BattleMenu_SwapDelay = 4;
                gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_1;
                btl_state_update_partner_menu();
                btl_state_update_partner_menu();
            } else {
                battleStatus->unk_4B = entryIdx - 1;
                func_802A27D0();
                func_802A1030();
                gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_ABILITIES_3;
            }
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_ABILITIES_3:
        entryIdx = btl_submenu_moves_update();
        if ((battleStatus->curButtonsPressed & BUTTON_B) && entryIdx == 0) {
            func_802A2AB8();
            func_802A1098();
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_ABILITIES_4;
        } else if (btl_main_menu_update() != 0) {
            battleStatus->moveCategory = BTL_MENU_TYPE_ABILITY;
            battleStatus->selectedMoveID = BattleMenu_Moves_OptionIndices[battleStatus->unk_4B];
            battleStatus->curTargetListFlags = gMoveTable[battleStatus->selectedMoveID].flags;
            battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_ABILITY] = battle_menu_moveOptionActive;
            battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_PARTNER_MENU_ABILITIES_5;
            battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_PARTNER_MENU_ABILITIES_6;
            btl_set_state(BATTLE_STATE_SELECT_TARGET);
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_ABILITIES_4:
        btl_submenu_moves_update();
        if (btl_main_menu_update() != 0) {
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_ABILITIES_2;
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_ABILITIES_5:
        func_802A2AB8();
        func_802A1098();
        gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_ABILITIES_4;
        break;
    case BTL_SUBSTATE_PARTNER_MENU_ABILITIES_6:
        func_802A27E4();
        btl_main_menu_destroy();
        break;
    case BTL_SUBSTATE_PARTNER_MENU_ABILITIES_7:
        if (btl_submenu_moves_update() != -1) {
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_ABILITIES_2;
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_ITEMS_1:
        popupIndex = 0;
        for (i = 0; i < ARRAY_COUNT(playerData->invItems); i++) {
            ItemData* item;
            HudScript** hudScript;
            if (playerData->invItems[i] == ITEM_NONE) {
                continue;
            }
            item = &gItemTable[playerData->invItems[i]];
            hudScript = &gItemHudScripts[item->hudElemID].enabled;
 
            if (!(item->typeFlags & ITEM_TYPE_FLAG_BATTLE_USABLE)) {
                continue;
            }
            popupMenu->ptrIcon[popupIndex] = hudScript[0];
            popupMenu->userIndex[popupIndex] = playerData->invItems[i];
            popupMenu->enabled[popupIndex] = TRUE;
            popupMenu->nameMsg[popupIndex] = item->nameMsg;
            popupMenu->descMsg[popupIndex] = item->shortDescMsg;
            popupIndex++;
        }
        if (battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_PARTNER_ITEM] < 0) {
            battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_PARTNER_ITEM] = 0;
        }
        popupMenu->popupType = POPUP_MENU_USE_ITEM;
        popupMenu->numEntries = popupIndex;
        popupMenu->dipMode = 0;
        popupMenu->titleNumber = 0;
        initialPos = battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_PARTNER_ITEM];
        popupMenu->initialPos = initialPos;
        create_battle_popup_menu(popupMenu);
        func_800F52BC();
        gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_ITEMS_2;
        break;
    case BTL_SUBSTATE_PARTNER_MENU_ITEMS_2:
        if (popupMenu->result != POPUP_RESULT_CHOOSING) {
            if (popupMenu->result == POPUP_RESULT_CANCEL) {
                func_802A1050();
                D_802ACC60 = 8;
                BattleMenu_SwapDelay = 4;
                gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_1;
                btl_state_update_partner_menu();
                btl_state_update_partner_menu();
            } else {
                battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_PARTNER_MENU_ITEMS_5;
                battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_PARTNER_MENU_ITEMS_6;
                battleStatus->unk_1AA = popupMenu->userIndex[popupMenu->result - 1];
                battleStatus->moveCategory = BTL_MENU_TYPE_ITEMS;
                battleStatus->moveArgument = battleStatus->unk_1AA;
                battleStatus->curTargetListFlags = gItemTable[battleStatus->moveArgument].targetFlags | TARGET_FLAG_PRIMARY_ONLY;
                battleStatus->curAttackElement = 0;
                battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_PARTNER_ITEM] = popupMenu->result - 1;
                hide_popup_menu();
                func_802A1030();
                gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_ITEMS_3;
            }
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_ITEMS_3:
        if ((battleStatus->curButtonsPressed & BUTTON_B) && popupMenu->result == POPUP_RESULT_CHOOSING) {
            func_800F16CC();
            func_802A1098();
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_ITEMS_4;
        } else if (btl_main_menu_update() != 0) {
            btl_set_state(BATTLE_STATE_SELECT_TARGET);
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_ITEMS_4:
        if (btl_main_menu_update() != 0) {
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_ITEMS_2;
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_ITEMS_5:
        func_800F16CC();
        func_802A1098();
        gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_ITEMS_4;
        break;
    case BTL_SUBSTATE_PARTNER_MENU_ITEMS_6:
        destroy_popup_menu();
        btl_main_menu_destroy();
        break;
    case BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_1:
        popupIndex = 0;
        for (i = 1; i < ARRAY_COUNT(PartnerIDFromMenuIndex); i++) {
            s32 partnerId = PartnerIDFromMenuIndex[i];
            if (playerData->partners[partnerId].enabled) {
                popupProps = &gPartnerPopupProperties[partnerId];
                popupMenu->ptrIcon[popupIndex] = battle_menu_PartnerHudScripts[partnerId];
                popupMenu->userIndex[popupIndex] = partnerId;
                popupMenu->enabled[popupIndex] = 1;
                popupMenu->nameMsg[popupIndex] = popupProps->nameMsg;
                popupMenu->descMsg[popupIndex] = popupProps->battleDescMsg;
                popupMenu->value[popupIndex] = playerData->partners[partnerId].level;
                if (playerData->curPartner == partnerId) {
                    popupMenu->enabled[popupIndex] = 0;
                    popupMenu->ptrIcon[popupIndex] = battle_menu_DisabledPartnerHudScripts[partnerId];
                }
                popupIndex++;
            }
        }
        if (battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_PARTNER] < 0) {
            battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_PARTNER] = 0;
        }
        popupMenu->popupType = POPUP_MENU_SWITCH_PARTNER;
        popupMenu->numEntries = popupIndex;
        popupMenu->initialPos = MenuIndexFromPartnerID[playerData->curPartner] - 1;
        popupMenu->dipMode = 0;
        popupMenu->titleNumber = 0;
        create_battle_popup_menu(popupMenu);
        func_800F52BC();
        gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_2;
        break;
    case BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_2:
        if (popupMenu->result == POPUP_RESULT_INVALID) {
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_7;
        } else if (popupMenu->result != POPUP_RESULT_CHOOSING) {
            if (popupMenu->result == POPUP_RESULT_CANCEL) {
                func_802A1050();
                D_802ACC60 = 8;
                BattleMenu_SwapDelay = 4;
                gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_1;
                btl_state_update_partner_menu();
                btl_state_update_partner_menu();
            } else {
                battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_5;
                battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_6;
                battleStatus->unk_1AC = popupMenu->userIndex[popupMenu->result - 1];
                battleStatus->moveCategory = BTL_MENU_TYPE_CHANGE_PARTNER;
                battleStatus->selectedMoveID = MOVE_UNUSED_37;
                battleStatus->curTargetListFlags = TARGET_FLAG_2;
                battleStatus->moveArgument = battleStatus->unk_1AC;
                battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_PARTNER] = popupMenu->result - 1;
                hide_popup_menu();
                func_802A1030();
                gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_3;
            }
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_3:
        if ((battleStatus->curButtonsPressed & BUTTON_B) && (popupMenu->result == POPUP_RESULT_CHOOSING)) {
            func_800F16CC();
            func_802A1098();
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_4;
        } else if (btl_main_menu_update() != 0) {
            gBattleSubState = battleStatus->acceptTargetMenuSubstate;
            btl_state_update_partner_menu();
            btl_set_state(BATTLE_STATE_CHANGE_PARTNER);
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_4:
        if (btl_main_menu_update() != 0) {
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_2;
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_5:
        func_800F16CC();
        func_802A1098();
        gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_4;
        break;
    case BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_6:
        destroy_popup_menu();
        btl_main_menu_destroy();
        break;
    case BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_7:
        if (popupMenu->result != POPUP_RESULT_INVALID) {
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_2;
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_FOCUS_1:
        entryIdx = 1;
        battleStatus->submenuMoves[0] = MOVE_FOCUS;
        battleStatus->submenuMoveCount = entryIdx;
        battleStatus->submenuIcons[0] = ITEM_PARTNER_ATTACK;
        battleStatus->submenuStatus[0] = 1;
        for (i = 0; i < battleStatus->submenuMoveCount; i++) {
            moveData = &gMoveTable[battleStatus->submenuMoves[i]];
            battle_menu_moveOptionIconScripts[i] = battle_menu_StarPowerMovesHudScripts[2 * STAR_POWER_INDEX(battleStatus->submenuMoves[i]) + 0];
            if (battleStatus->submenuStatus[i] == 0) {
                battle_menu_moveOptionIconScripts[i] = battle_menu_StarPowerMovesHudScripts[2 * STAR_POWER_INDEX(battleStatus->submenuMoves[i]) + 1];
            }
            battle_menu_moveOptionDisplayCosts[i] = moveData->costFP;
            battle_menu_moveOptionBPCosts[i] = moveData->costBP;
            BattleMenu_Moves_OptionIndices[i] = i;
            BattleMenu_Moves_OptionSortPriority[i] = i;
            BattleMenu_Moves_OptionEnabled[i] = battleStatus->submenuStatus[i];
            battle_menu_moveOptionNames[i] = moveData->nameMsg;
            BattleMenu_Moves_OptionDescMessages[i] = moveData->shortDescMsg;
            battle_menu_moveOptionDisplayCostReductions[i] = 0;
            battle_menu_moveOptionDisplayCostReductionColors[i] = 0;
        }
        if (battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_STAR_POWER] < 0) {
            battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_STAR_POWER] = 0;
        }
        BattleMenu_UsingSpiritsSubmenu = TRUE;
        BattleMenu_Moves_OptionCount = battleStatus->submenuMoveCount;
        initialPos = battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_STAR_POWER];
        D_802AD4A8 = initialPos;
        func_802A2684();
        gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_FOCUS_2;
        break;
    case BTL_SUBSTATE_PARTNER_MENU_FOCUS_2:
        entryIdx = btl_submenu_moves_update();
        if (entryIdx != 0) {
            if (entryIdx == 255) {
                func_802A1050();
                D_802ACC60 = 8;
                BattleMenu_SwapDelay = 4;
                gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_1;
                btl_state_update_partner_menu();
                btl_state_update_partner_menu();
            } else {
                battleStatus->unk_4B = BattleMenu_Moves_OptionIndices[entryIdx - 1];
                func_802A27D0();
                func_802A1030();
                gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_FOCUS_3;
            }
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_FOCUS_3:
        entryIdx = btl_submenu_moves_update();
        if ((battleStatus->curButtonsPressed & BUTTON_B) && (entryIdx == 0)) {
            func_802A2AB8();
            func_802A1098();
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_FOCUS_4;
        } else if (btl_main_menu_update() != 0) {
            battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_PARTNER_MENU_FOCUS_5;
            battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_PARTNER_MENU_FOCUS_6;
            battleStatus->moveCategory = BTL_MENU_TYPE_STAR_POWERS;
            battleStatus->selectedMoveID = battleStatus->submenuMoves[battleStatus->unk_4B];
            battleStatus->curTargetListFlags = gMoveTable[battleStatus->submenuMoves[battleStatus->unk_4B]].flags;
            battleStatus->moveArgument = battleStatus->unk_4B;
            battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_STAR_POWER] = battle_menu_moveOptionActive;
            btl_set_state(BATTLE_STATE_SELECT_TARGET);
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_FOCUS_4:
        btl_submenu_moves_update();
        if (btl_main_menu_update() != 0) {
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_FOCUS_2;
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_FOCUS_5:
        func_802A2AB8();
        func_802A1098();
        gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_FOCUS_4;
        break;
    case BTL_SUBSTATE_PARTNER_MENU_FOCUS_6:
        func_802A27E4();
        btl_main_menu_destroy();
        break;
    case BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_1:
        popupIndex = 0;
        btl_check_can_change_partner();
 
        // add 'Change Member' command
        if (battleStatus->changePartnerAllowed >= 0) {
            D_802AD678[popupIndex] = BTL_MENU_TYPE_CHANGE_PARTNER;
            D_802AD658[popupIndex] = BattleMenu_LeftJustMessages[BTL_MENU_TYPE_CHANGE_PARTNER];
            D_802AD640[popupIndex] = battle_menu_PartnerHudScripts[playerData->curPartner];
            D_802AD690[popupIndex] = 1;
            D_802AD6C0[popupIndex] = MSG_Menus_Action_ChangePartner;
            if (battleStatus->changePartnerAllowed <= 0) {
                D_802AD640[popupIndex] = battle_menu_DisabledPartnerHudScripts[playerData->curPartner];
                D_802AD690[popupIndex] = 0;
                D_802AD6A8[popupIndex] = 0;
            }
            popupIndex++;
        }
 
        // add 'Do Nothing' command
        D_802AD640[popupIndex] = battle_menu_DoNothingHudScripts.enabled;
        D_802AD678[popupIndex] = BTL_MENU_TYPE_DO_NOTHING;
        D_802AD690[popupIndex] = 1;
        D_802AD658[popupIndex] = BattleMenu_LeftJustMessages[BTL_MENU_TYPE_DO_NOTHING];
        D_802AD6C0[popupIndex] = MSG_Menus_Action_DoNothing;
        popupIndex++;
 
        if (battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_STRATEGY] < 0) {
            battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_STRATEGY] = 0;
        }
        D_802AD66C = popupIndex;
        initialPos = battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_STRATEGY];
        StratsMenuLastPos = initialPos;
        func_802A45D8();
        gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_2;
        break;
    case BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_2:
        entryIdx = btl_update_strats_menu();
        if (entryIdx == 0) {
        } else if (entryIdx == 255) {
            func_802A1050();
            D_802ACC60 = 8;
            BattleMenu_SwapDelay = 4;
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_1;
            btl_state_update_partner_menu();
            btl_state_update_partner_menu();
        } else {
            battleStatus->curPartnerSubmenu = D_802AD678[entryIdx - 1];
            battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_STRATEGY] = entryIdx - 1;
            if (battleStatus->curPartnerSubmenu == 5) { // change partner
                gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_1;
                btl_state_update_partner_menu();
                btl_state_update_partner_menu();
            } else {
                func_802A4718();
                func_802A1030();
                gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_3;
            }
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_3:
        entryIdx = btl_update_strats_menu();
        if ((battleStatus->curButtonsPressed & BUTTON_B) && entryIdx == 0) {
            func_802A48FC();
            func_802A1098();
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_4;
        } else if (btl_main_menu_update() != 0) {
            battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_5;
            battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_6;
            entryIdx = battleStatus->curPartnerSubmenu;
            switch (entryIdx) {
                case 9:
                    gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_6;
                    btl_state_update_partner_menu();
                    btl_set_state(BATTLE_STATE_END_PARTNER_TURN);
                    break;
                case 3:
                    gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_6;
                    btl_state_update_partner_menu();
                    battleStatus->moveCategory = entryIdx;
                    battleStatus->selectedMoveID = MOVE_UNUSED_39;
                    btl_set_state(BATTLE_STATE_RUN_AWAY);
                    break;
                case 10:
                    gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_6;
                    btl_state_update_partner_menu();
                    btl_set_state(BATTLE_STATE_SWITCH_TO_PLAYER);
                    break;
            }
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_4:
        btl_update_strats_menu();
        if (btl_main_menu_update() != 0) {
            D_802ACC60 = 8;
            BattleMenu_SwapDelay = 4;
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_1;
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_5:
        func_802A48FC();
        func_802A1098();
        gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_4;
        break;
    case BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_6:
        func_802A472C();
        btl_main_menu_destroy();
        break;
    case BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_1:
        popupIndex = 0;
        for (i = 1; i < ARRAY_COUNT(PartnerIDFromMenuIndex); i++) {
            s32 partnerId = PartnerIDFromMenuIndex[i];
            if (playerData->partners[partnerId].enabled) {
                popupProps = &gPartnerPopupProperties[partnerId];
                popupMenu->ptrIcon[popupIndex] = battle_menu_PartnerHudScripts[partnerId];
                popupMenu->userIndex[popupIndex] = partnerId;
                popupMenu->enabled[popupIndex] = 1;
                popupMenu->nameMsg[popupIndex] = popupProps->nameMsg;
                popupMenu->descMsg[popupIndex] = popupProps->battleDescMsg;
                popupMenu->value[popupIndex] = playerData->partners[partnerId].level;
                if (playerData->curPartner == partnerId) {
                    popupMenu->enabled[popupIndex] = 0;
                    popupMenu->ptrIcon[popupIndex] = battle_menu_DisabledPartnerHudScripts[partnerId];
                }
                popupIndex++;
            }
        }
        if (battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_PARTNER] < 0) {
            battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_PARTNER] = 0;
        }
        popupMenu->popupType = POPUP_MENU_SWITCH_PARTNER;
        popupMenu->numEntries = popupIndex;
        popupMenu->initialPos = MenuIndexFromPartnerID[playerData->curPartner] - 1;
        popupMenu->dipMode = 0;
        popupMenu->titleNumber = 0;
        create_battle_popup_menu(popupMenu);
        func_800F52BC();
        gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_2;
        break;
    case BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_2:
        if (popupMenu->result == POPUP_RESULT_INVALID) {
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_7;
        } else if (popupMenu->result != POPUP_RESULT_CHOOSING) {
            if (popupMenu->result == POPUP_RESULT_CANCEL) {
                func_802A47E0();
                gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_2;
                btl_state_update_partner_menu();
                btl_state_update_partner_menu();
            } else {
                battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_5;
                battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_6;
                battleStatus->unk_1AC = popupMenu->userIndex[popupMenu->result - 1];
                battleStatus->moveCategory = BTL_MENU_TYPE_CHANGE_PARTNER;
                battleStatus->selectedMoveID = MOVE_UNUSED_37;
                battleStatus->curTargetListFlags = TARGET_FLAG_2;
                battleStatus->moveArgument = battleStatus->unk_1AC;
                battleStatus->lastPartnerMenuSelection[BTL_MENU_IDX_PARTNER] = popupMenu->result - 1;
                hide_popup_menu();
                func_802A4718();
                func_802A1030();
                gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_3;
            }
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_3:
        if ((battleStatus->curButtonsPressed & BUTTON_B) && popupMenu->result == POPUP_RESULT_CHOOSING) {
            func_800F16CC();
            func_802A4A10();
            func_802A1098();
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_4;
        } else {
            btl_update_strats_menu();
            if (btl_main_menu_update() != 0) {
                gBattleSubState = battleStatus->acceptTargetMenuSubstate;
                btl_state_update_partner_menu();
                btl_set_state(BATTLE_STATE_CHANGE_PARTNER);
            }
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_4:
        btl_update_strats_menu();
        if (btl_main_menu_update() != 0) {
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_2;
        }
        break;
    case BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_5:
        func_800F16CC();
        func_802A4A10();
        func_802A1098();
        gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_4;
        break;
    case BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_6:
        destroy_popup_menu();
        func_802A472C();
        btl_main_menu_destroy();
        break;
    case BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_7:
        set_window_update(WIN_BTL_STRATS_MENU, WINDOW_UPDATE_HIDE);
        set_window_update(WIN_BTL_STRATS_TITLE, WINDOW_UPDATE_HIDE);
        if (popupMenu->result != POPUP_RESULT_INVALID) {
            set_window_update(WIN_BTL_STRATS_MENU, WINDOW_UPDATE_9);
            set_window_update(WIN_BTL_STRATS_TITLE, WINDOW_UPDATE_9);
            gBattleSubState = BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_2;
        }
        break;
    }
}

Referenced by btl_state_update_partner_menu(), btl_state_update_select_target(), and btl_update().

◆ btl_state_draw_partner_menu()

void btl_state_draw_partner_menu ( void )

Definition at line 4456 of file btl_states_menus.c.

                                       {
    switch (gBattleSubState) {
        case BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_1:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_2:
        case BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_3:
        case BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_4:
        case BTL_SUBSTATE_PARTNER_MENU_MAIN_MENU_5:
        case BTL_SUBSTATE_PARTNER_MENU_ABILITIES_1:
        case BTL_SUBSTATE_PARTNER_MENU_ABILITIES_2:
        case BTL_SUBSTATE_PARTNER_MENU_ABILITIES_3:
        case BTL_SUBSTATE_PARTNER_MENU_ABILITIES_4:
        case BTL_SUBSTATE_PARTNER_MENU_ABILITIES_5:
        case BTL_SUBSTATE_PARTNER_MENU_UNKNOWN_1:
        case BTL_SUBSTATE_PARTNER_MENU_UNKNOWN_2:
        case BTL_SUBSTATE_PARTNER_MENU_UNKNOWN_3:
        case BTL_SUBSTATE_PARTNER_MENU_UNKNOWN_4:
        case BTL_SUBSTATE_PARTNER_MENU_UNKNOWN_5:
        case BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_1:
        case BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_2:
        case BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_3:
        case BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_4:
        case BTL_SUBSTATE_PARTNER_MENU_CHANGE_PARTNER_5:
        case BTL_SUBSTATE_PARTNER_MENU_ITEMS_1:
        case BTL_SUBSTATE_PARTNER_MENU_ITEMS_2:
        case BTL_SUBSTATE_PARTNER_MENU_ITEMS_3:
        case BTL_SUBSTATE_PARTNER_MENU_ITEMS_4:
        case BTL_SUBSTATE_PARTNER_MENU_ITEMS_5:
        case BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_2:
        case BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_3:
        case BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_4:
        case BTL_SUBSTATE_PARTNER_MENU_UNUSED_CHANGE_PARTNER_5:
        case BTL_SUBSTATE_PARTNER_MENU_FOCUS_2:
        case BTL_SUBSTATE_PARTNER_MENU_FOCUS_3:
        case BTL_SUBSTATE_PARTNER_MENU_FOCUS_4:
        case BTL_SUBSTATE_PARTNER_MENU_FOCUS_5:
        case BTL_SUBSTATE_PARTNER_MENU_FOCUS_6:
        case BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_1:
        case BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_2:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_3:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_4:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_5:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_PARTNER_MENU_STRATEGIES_6:
            btl_main_menu_draw();
            break;
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_peach_menu()

void btl_state_update_peach_menu ( void )

Definition at line 4520 of file btl_states_menus.c.

                                       {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    s32 selectedOption;
    s32 initialPos;
    s32 entryIdx;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_PEACH_MENU_INIT:
            btl_cam_use_preset(BTL_CAM_DEFAULT);
            btl_cam_move(10);
            if (!(gBattleStatus.flags1 & BS_FLAGS1_PLAYER_IN_BACK)) {
                gBattleSubState = BTL_SUBSTATE_PEACH_CREATE_MAIN_MENU;
                break;
            }
            player->state.curPos.x = player->homePos.x;
            player->state.curPos.z = player->homePos.z;
            gBattleSubState = BTL_SUBSTATE_PEACH_MENU_PERFORM_SWAP;
            player->state.goalPos.x = partner->homePos.x;
            player->state.goalPos.z = partner->homePos.z;
            player->state.moveTime = 4;
            player->state.angle = 0.0f;
            break;
        case BTL_SUBSTATE_PEACH_MENU_PERFORM_SWAP:
            if (player->state.moveTime != 0) {
                player->curPos.x += (player->state.goalPos.x - player->curPos.x) / player->state.moveTime;
                player->curPos.z += (player->state.goalPos.z - player->curPos.z) / player->state.moveTime;
                partner->curPos.x += (player->state.curPos.x - partner->curPos.x) / player->state.moveTime;
                partner->curPos.z += (player->state.curPos.z - partner->curPos.z) / player->state.moveTime;
            }
 
            player->curPos.z -= sin_rad(DEG_TO_RAD(player->state.angle)) * 16.0f;
            player->yaw = clamp_angle(-player->state.angle);
            partner->curPos.z += sin_rad(DEG_TO_RAD(player->state.angle)) * 16.0f;
            partner->yaw = clamp_angle(-player->state.angle);
            player->state.angle += 90.0f;
 
            if (player->state.moveTime != 0) {
                player->state.moveTime--;
                break;
            }
 
            player->curPos.x = player->state.goalPos.x;
            player->curPos.z = player->state.goalPos.z;
            partner->curPos.x = player->state.curPos.x;
            partner->curPos.z = player->state.curPos.z;
            player->homePos.x = player->curPos.x;
            player->homePos.z = player->curPos.z;
            partner->homePos.x = partner->curPos.x;
            partner->homePos.z = partner->curPos.z;
            gBattleStatus.flags1 &= ~BS_FLAGS1_PLAYER_IN_BACK;
        case BTL_SUBSTATE_PEACH_CREATE_MAIN_MENU:
            gBattleStatus.flags1 |= BS_FLAGS1_MENU_OPEN;
            player->flags &= ~ACTOR_FLAG_USING_IDLE_ANIM;
            player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            if (partner != NULL) {
                partner->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
                partner->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            }
 
            entryIdx = 0;
            battleStatus->selectedMoveID = MOVE_NONE;
            battle_menu_submenuIDs[entryIdx] = BTL_MENU_TYPE_STAR_POWERS;
            BattleMenu_OptionEnabled[entryIdx] = TRUE;
            battle_menu_isMessageDisabled[entryIdx] = 0;
            BattleMenu_HudScripts[entryIdx] = battle_menu_PeachStarPowerHudScripts.enabled;
            BattleMenu_TitleMessages[entryIdx] = D_802AB728[entryIdx];
            if (!(battleStatus->enabledMenusFlags & BTL_MENU_ENABLED_STAR_POWERS)) {
                BattleMenu_OptionEnabled[entryIdx] = FALSE;
                battle_menu_isMessageDisabled[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
                BattleMenu_HudScripts[entryIdx] = battle_menu_PeachStarPowerHudScripts.disabled;
            }
 
            initialPos = 0;
            entryIdx++;
 
            if (btl_menu_show_switch_to_twink()) {
                BattleMenu_ShowSwapIcons = TRUE;
            } else {
                BattleMenu_ShowSwapIcons = FALSE;
            }
            BattleMenu_NumOptions = entryIdx;
            D_802AD0A8 = 0;
            D_802AD0B0 = initialPos;
            D_802AD100 = 2 - initialPos;
 
            btl_main_menu_init();
            D_802ACC60 = 8;
            gBattleSubState = BTL_SUBSTATE_PEACH_MENU_CHOOSE_CATEGORY;
            break;
        case BTL_SUBSTATE_PEACH_MENU_CHOOSE_CATEGORY:
            set_actor_anim(ACTOR_PLAYER, 0, ANIM_Peach2_Delighted);
            selectedOption = btl_main_menu_update();
            if (D_802ACC60 != 0) {
                D_802ACC60--;
                break;
            }
            if (selectedOption != 0) {
                set_actor_anim(ACTOR_PLAYER, 0, ANIM_Peach1_Walk);
                battleStatus->curSubmenu = battle_menu_submenuIDs[selectedOption - 1];
                func_802A1030();
                D_802ACC60 = 8;
                BattleMenu_SwapDelay = 4;
                gBattleSubState = BTL_SUBSTATE_PEACH_MENU_CHOOSE_TARGET;
            }
            break;
        case BTL_SUBSTATE_PEACH_MENU_CHOOSE_TARGET:
            if (btl_main_menu_update() != 0) {
                battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_PEACH_MENU_TARGET_CANCEL;
                battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_PEACH_MENU_TARGET_CHOSEN;
                battleStatus->curTargetListFlags = gMoveTable[MOVE_PEACH_FOCUS].flags;
                battleStatus->moveCategory = BTL_MENU_TYPE_STAR_POWERS;
                battleStatus->selectedMoveID = MOVE_PEACH_FOCUS;
                battleStatus->moveArgument = STAR_POWER_INDEX(MOVE_PEACH_FOCUS);
                btl_set_state(BATTLE_STATE_SELECT_TARGET);
            }
            break;
        case BTL_SUBSTATE_PEACH_MENU_TARGET_CANCEL:
            func_802A1050();
            gBattleSubState = BTL_SUBSTATE_PEACH_MENU_CHOOSE_CATEGORY;
            btl_state_update_peach_menu();
            btl_state_update_peach_menu();
            break;
        case BTL_SUBSTATE_PEACH_MENU_TARGET_CHOSEN:
            btl_main_menu_destroy();
            break;
        case BTL_SUBSTATE_PEACH_MENU_SHOW_CANT_SWITCH:
            btl_show_variable_battle_message(BTL_MSG_CANT_SWITCH, 60, 0);
            ShowingErrorMessage = TRUE;
            gBattleSubState = BTL_SUBSTATE_PEACH_MENU_AWAIT_CANT_SWITCH_POPUP;
            break;
        case BTL_SUBSTATE_PEACH_MENU_AWAIT_CANT_SWITCH_POPUP:
            if (btl_is_popup_displayed()) {
                break;
            }
            ShowingErrorMessage = FALSE;
            D_802ACC60 = 0;
            gBattleSubState = BTL_SUBSTATE_PEACH_MENU_CHOOSE_CATEGORY;
            break;
    }
}

Referenced by btl_state_update_peach_menu(), btl_state_update_select_target(), and btl_update().

◆ btl_state_draw_peach_menu()

void btl_state_draw_peach_menu ( void )

Definition at line 4663 of file btl_states_menus.c.

                                     {
    switch (gBattleSubState) {
        case BTL_SUBSTATE_PEACH_MENU_CHOOSE_CATEGORY:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_PEACH_MENU_CHOOSE_TARGET:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_PEACH_MENU_UNUSED_3:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_PEACH_MENU_TARGET_CANCEL:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_PEACH_MENU_TARGET_CHOSEN:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_PEACH_MENU_UNUSED_6:
        case BTL_SUBSTATE_PEACH_MENU_UNUSED_7:
        case BTL_SUBSTATE_PEACH_MENU_SHOW_CANT_SWITCH:
        case BTL_SUBSTATE_PEACH_MENU_AWAIT_CANT_SWITCH_POPUP:
            break;
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_twink_menu()

void btl_state_update_twink_menu ( void )

Definition at line 4695 of file btl_states_menus.c.

                                       {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    s32 s1;
    s32 selection;
    s32 var_v0_2;
    s32 shouldSkipTurn;
    s32 initialPos;
    s32 entryIdx;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_TWINK_MENU_INIT:
            shouldSkipTurn = FALSE;
            if (player->debuff == STATUS_KEY_SLEEP) {
                shouldSkipTurn = TRUE;
            }
            if (player->debuff == STATUS_KEY_FEAR) {
                shouldSkipTurn = TRUE;
            }
            if (player->debuff == STATUS_KEY_DIZZY) {
                shouldSkipTurn = TRUE;
            }
            if (player->debuff == STATUS_KEY_PARALYZE) {
                shouldSkipTurn = TRUE;
            }
            if (player->debuff == STATUS_KEY_FROZEN) {
                shouldSkipTurn = TRUE;
            }
            if (player->debuff == STATUS_KEY_STOP) {
                shouldSkipTurn = TRUE;
            }
            if (player->stoneStatus == STATUS_KEY_STONE) {
                shouldSkipTurn = TRUE;
            }
            if (player->koStatus == STATUS_KEY_DAZE) {
                shouldSkipTurn = TRUE;
            }
 
            if (shouldSkipTurn) {
                btl_set_state(BATTLE_STATE_END_PLAYER_TURN);
                break;
            }
 
            btl_cam_use_preset(BTL_CAM_DEFAULT);
            btl_cam_move(10);
            if (!(gBattleStatus.flags1 & BS_FLAGS1_PLAYER_IN_BACK)) {
                player->state.curPos.x = player->homePos.x;
                player->state.curPos.z = player->homePos.z;
                player->state.goalPos.x = partner->homePos.x;
                player->state.goalPos.z = partner->homePos.z;
                gBattleSubState = BTL_SUBSTATE_TWINK_MENU_PERFORM_SWAP;
                player->state.moveTime = 4;
                player->state.angle = 0.0f;
                break;
            }
            gBattleSubState = BTL_SUBSTATE_TWINK_MENU_CREATE_MAIN_MENU;
            break;
        case BTL_SUBSTATE_TWINK_MENU_PERFORM_SWAP:
            if (player->state.moveTime != 0) {
                player->curPos.x += (player->state.goalPos.x - player->curPos.x) / player->state.moveTime;
                player->curPos.z += (player->state.goalPos.z - player->curPos.z) / player->state.moveTime;
                partner->curPos.x += (player->state.curPos.x - partner->curPos.x) / player->state.moveTime;
                partner->curPos.z += (player->state.curPos.z - partner->curPos.z) / player->state.moveTime;
            }
            player->curPos.z += sin_rad(DEG_TO_RAD(player->state.angle)) * 16.0f;
            player->yaw = clamp_angle(-player->state.angle);
            partner->curPos.z -= sin_rad(DEG_TO_RAD(player->state.angle)) * 16.0f;
            partner->yaw = clamp_angle(-player->state.angle);
            player->state.angle += 90.0f;
            if (player->state.moveTime != 0) {
                player->state.moveTime--;
                break;
            }
            player->curPos.x = player->state.goalPos.x;
            player->curPos.z = player->state.goalPos.z;
            partner->curPos.x = player->state.curPos.x;
            partner->curPos.z = player->state.curPos.z;
            player->homePos.x = player->curPos.x;
            player->homePos.z = player->curPos.z;
            partner->homePos.x = partner->curPos.x;
            partner->homePos.z = partner->curPos.z;
            gBattleStatus.flags1 |= BS_FLAGS1_PLAYER_IN_BACK;
        case BTL_SUBSTATE_TWINK_MENU_CREATE_MAIN_MENU:
            gBattleStatus.flags1 |= BS_FLAGS1_MENU_OPEN;
            player->flags &= ~ACTOR_FLAG_USING_IDLE_ANIM;
            player->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            if (partner != NULL) {
                partner->flags |= ACTOR_FLAG_USING_IDLE_ANIM;
                partner->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
            }
 
            entryIdx = 0;
            battleStatus->selectedMoveID = MOVE_NONE;
            battle_menu_submenuIDs[entryIdx] = BTL_MENU_TYPE_STAR_POWERS;
            BattleMenu_OptionEnabled[entryIdx] = TRUE;
            battle_menu_isMessageDisabled[entryIdx] = 0;
            BattleMenu_HudScripts[entryIdx] = battle_menu_TwinkStarPowerHudScripts.enabled;
            BattleMenu_TitleMessages[entryIdx] = D_802AB734[entryIdx];
            if (!(battleStatus->enabledMenusFlags & BTL_MENU_ENABLED_STAR_POWERS)) {
                BattleMenu_OptionEnabled[entryIdx] = FALSE;
                battle_menu_isMessageDisabled[entryIdx] = BTL_MSG_CANT_SELECT_NOW;
                BattleMenu_HudScripts[entryIdx] = battle_menu_TwinkStarPowerHudScripts.disabled;
            }
 
            initialPos = 0;
            entryIdx++;
 
            if (btl_menu_show_switch_to_peach()) {
                BattleMenu_ShowSwapIcons = TRUE;
            } else {
                BattleMenu_ShowSwapIcons = FALSE;
            }
            BattleMenu_NumOptions = entryIdx;
            D_802AD0A8 = 0;
            D_802AD0B0 = initialPos;
            D_802AD100 = 2 - initialPos;
 
            btl_main_menu_init();
            D_802ACC60 = 8;
            gBattleSubState = BTL_SUBSTATE_TWINK_MENU_CHOOSE_CATEGORY;
            break;
        case BTL_SUBSTATE_TWINK_MENU_CHOOSE_CATEGORY:
            set_actor_anim(ACTOR_PARTNER, 0, ANIM_Twink_Idle);
            selection = btl_main_menu_update();
            if (D_802ACC60 != 0) {
                D_802ACC60--;
                break;
            }
            if (selection != 0) {
                set_actor_anim(ACTOR_PARTNER, 0, ANIM_Twink_Angry);
                battleStatus->curSubmenu = battle_menu_submenuIDs[selection - 1];
                func_802A1030();
                D_802ACC60 = 8;
                BattleMenu_SwapDelay = 4;
                gBattleSubState = BTL_SUBSTATE_TWINK_MENU_CHOOSE_TARGET;
            }
            break;
        case BTL_SUBSTATE_TWINK_MENU_CHOOSE_TARGET:
            if (btl_main_menu_update() != 0) {
                battleStatus->cancelTargetMenuSubstate = BTL_SUBSTATE_TWINK_MENU_TARGET_CANCEL;
                battleStatus->acceptTargetMenuSubstate = BTL_SUBSTATE_TWINK_MENU_TARGET_CHOSEN;
                battleStatus->moveCategory = BTL_MENU_TYPE_STAR_POWERS;
                battleStatus->selectedMoveID = MOVE_TWINK_DASH;
                battleStatus->moveArgument = 0;
                battleStatus->curTargetListFlags = gMoveTable[MOVE_TWINK_DASH].flags;
                btl_set_state(BATTLE_STATE_SELECT_TARGET);
            }
            break;
        case BTL_SUBSTATE_TWINK_MENU_TARGET_CANCEL:
            func_802A1050();
            gBattleSubState = BTL_SUBSTATE_TWINK_MENU_CHOOSE_CATEGORY;
            btl_state_update_twink_menu();
            btl_state_update_twink_menu();
            break;
        case BTL_SUBSTATE_TWINK_MENU_TARGET_CHOSEN:
            btl_main_menu_destroy();
            break;
        case BTL_SUBSTATE_TWINK_MENU_SHOW_CANT_SWITCH:
            btl_show_variable_battle_message(BTL_MSG_CANT_SWITCH, 60, 0);
            ShowingErrorMessage = TRUE;
            gBattleSubState = BTL_SUBSTATE_TWINK_MENU_AWAIT_CANT_SWITCH_POPUP;
            break;
        case BTL_SUBSTATE_TWINK_MENU_AWAIT_CANT_SWITCH_POPUP:
            if (btl_is_popup_displayed()) {
                break;
            }
            ShowingErrorMessage = FALSE;
            D_802ACC60 = 0;
            gBattleSubState = BTL_SUBSTATE_TWINK_MENU_CHOOSE_CATEGORY;
            break;
    }
}

Referenced by btl_state_update_select_target(), btl_state_update_twink_menu(), and btl_update().

◆ btl_state_draw_twink_menu()

void btl_state_draw_twink_menu ( void )

Definition at line 4869 of file btl_states_menus.c.

                                     {
    switch (gBattleSubState) {
        case BTL_SUBSTATE_TWINK_MENU_CHOOSE_CATEGORY:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_TWINK_MENU_CHOOSE_TARGET:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_TWINK_MENU_UNUSED_3:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_TWINK_MENU_TARGET_CANCEL:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_TWINK_MENU_TARGET_CHOSEN:
            btl_main_menu_draw();
            break;
        case BTL_SUBSTATE_TWINK_MENU_UNUSED_6:
        case BTL_SUBSTATE_TWINK_MENU_UNUSED_7:
        case BTL_SUBSTATE_TWINK_MENU_SHOW_CANT_SWITCH:
        case BTL_SUBSTATE_TWINK_MENU_AWAIT_CANT_SWITCH_POPUP:
            break;
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_select_target()

void btl_state_update_select_target ( void )

Definition at line 4894 of file btl_states_menus.c.

                                          {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* actor;
    s32 targetListLength;
    s32 selectedTargetIndex;
    HudElemID hid;
    s8* targetIndexList;
    SelectableTarget* target;
    s32 i;
 
    if (!(gBattleStatus.flags1 & BS_FLAGS1_PARTNER_ACTING)) {
        actor = battleStatus->playerActor;
    } else {
        actor = battleStatus->partnerActor;
    }
    targetListLength = actor->targetListLength;
    selectedTargetIndex = actor->selectedTargetIndex;
 
    actor->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
    targetIndexList = actor->targetIndexList;
    switch (gBattleSubState) {
        case BTL_SUBSTATE_SELECT_TARGET_INIT:
            BattleMenu_TargetPointerAlpha = 255;
            BattleMenu_TargetNameOffsetX = -100;
            gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
 
            // prepare the action command tip for the selected move
            if (!is_ability_active(ABILITY_BERSERKER) || (gBattleStatus.flags1 & BS_FLAGS1_PARTNER_ACTING)) {
                if (battleStatus->selectedMoveID != MOVE_NONE) {
                    s8 actionTip = gMoveTable[battleStatus->selectedMoveID].actionTip;
 
                    if (actionTip >= 0) {
                        btl_show_battle_message(BTL_MSG_ACTION_TIP_PRESS_BEFORE_LANDING + actionTip, 60);
                    }
                }
            }
 
            // create the target list
            create_current_pos_target_list(actor);
            targetListLength = actor->targetListLength;
            if (battleStatus->curTargetListFlags & TARGET_FLAG_SELECT_ONE) {
                targetIndexList = actor->targetIndexList;
                for (i = 0; i < targetListLength; i++) {
                    target = &actor->targetData[targetIndexList[i]];
                    if (get_actor_part(get_actor(target->actorID), target->partID)->flags & ACTOR_PART_FLAG_DEFAULT_TARGET) {
                        actor->selectedTargetIndex = i;
                        break;
                    }
                }
            }
 
            // when TARGET_FLAG_OVERRIDE is set, skip selecting a target and begin executing the move
            if (battleStatus->curTargetListFlags & TARGET_FLAG_OVERRIDE) {
                if (!(gBattleStatus.flags1 & BS_FLAGS1_PARTNER_ACTING)) {
                    gBattleSubState = battleStatus->acceptTargetMenuSubstate;
                    if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                        btl_state_update_player_menu();
                    } else {
                        btl_state_update_player_menu();
                    }
                    btl_set_state(BATTLE_STATE_PLAYER_MOVE);
                } else {
                    gBattleSubState = battleStatus->acceptTargetMenuSubstate;
                    if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                        btl_state_update_twink_menu();
                    } else {
                        btl_state_update_partner_menu();
                    }
                    btl_set_state(BATTLE_STATE_PARTNER_MOVE);
                }
                break;
            }
 
            // if the target list is empty, skip selecting a target and begin executing the move
            if (targetListLength == 0) {
                if (!(gBattleStatus.flags1 & BS_FLAGS1_PARTNER_ACTING)) {
                    gBattleSubState = battleStatus->acceptTargetMenuSubstate;
                    if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                        btl_state_update_player_menu();
                    } else {
                        btl_state_update_player_menu();
                    }
                    btl_set_state(BATTLE_STATE_PLAYER_MOVE);
                } else {
                    gBattleSubState = battleStatus->acceptTargetMenuSubstate;
                    if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                        btl_state_update_twink_menu();
                    } else {
                        btl_state_update_partner_menu();
                    }
                    btl_set_state(BATTLE_STATE_PARTNER_MOVE);
                }
                break;
            }
 
            // create the HUD elements for the target pointers
            for (i = 0; i < targetListLength; i++) {
                hid = hud_element_create(&HES_HandPointDownLoop);
                BattleMenu_TargetHudElems[i] = hid;
                hud_element_set_render_depth(hid, 0);
                hud_element_set_render_pos(hid, 0, -100);
            }
            gBattleSubState = BTL_SUBSTATE_SELECT_TARGET_CHOOSE;
            break;
        case BTL_SUBSTATE_SELECT_TARGET_CHOOSE:
            // animate the target name sliding into view
            if (BattleMenu_TargetNameOffsetX < 0) {
                BattleMenu_TargetNameOffsetX += 20;
                if (BattleMenu_TargetNameOffsetX > 0) {
                    BattleMenu_TargetNameOffsetX = 0;
                }
            }
 
            if (battleStatus->curButtonsPressed & BUTTON_B) {
                sfx_play_sound(SOUND_MENU_BACK);
                gBattleSubState = BTL_SUBSTATE_SELECT_TARGET_CANCEL;
                break;
            }
 
            if (battleStatus->curButtonsPressed & BUTTON_A) {
                sfx_play_sound(SOUND_MENU_NEXT);
                D_802ACC60 = 8;
                BattleMenu_SwapDelay = 4;
                gBattleSubState = BTL_SUBSTATE_SELECT_TARGET_DONE;
                break;
            }
 
            gBattleStatus.flags1 |= BS_FLAGS1_MENU_OPEN;
            if (battleStatus->curButtonsDown & (BUTTON_Z | BUTTON_R)) {
                gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
                break;
            }
 
            if (battleStatus->curTargetListFlags & TARGET_FLAG_SELECT_ONE) {
                s32 oldSelectedTargetIndex = selectedTargetIndex;
 
                if (battleStatus->curButtonsHeld & BUTTON_STICK_LEFT) {
                    selectedTargetIndex--;
                }
                if (battleStatus->curButtonsHeld & BUTTON_STICK_RIGHT) {
                    selectedTargetIndex++;
                }
                if (selectedTargetIndex < 0) {
                    selectedTargetIndex = targetListLength - 1;
                }
                if (selectedTargetIndex >= targetListLength) {
                    selectedTargetIndex = 0;
                }
                if (selectedTargetIndex != oldSelectedTargetIndex) {
                    s32 actorFlags;
 
                    target = &actor->targetData[targetIndexList[selectedTargetIndex]];
                    actorFlags = get_actor(target->actorID)->flags;
                    hid = BattleMenu_TargetHudElems[0];
 
                    if (actorFlags & ACTOR_FLAG_UPSIDE_DOWN) {
                        hud_element_set_script(hid, &HES_HandPointLeftLoop);
                    } else {
                        hud_element_set_script(hid, &HES_HandPointDownLoop);
                    }
                    sfx_play_sound(SOUND_MENU_CHANGE_SELECTION);
                }
                actor->selectedTargetIndex = selectedTargetIndex;
            }
            break;
        case BTL_SUBSTATE_SELECT_TARGET_DONE:
            gBattleStatus.flags1 &= ~BS_FLAGS1_MENU_OPEN;
            target = &actor->targetData[targetIndexList[actor->selectedTargetIndex]];
            actor->targetActorID = target->actorID;
            actor->targetPartID = target->partID;
 
            // free the HUD elements for the target pointers
            for (i = 0; i < targetListLength; i++) {
                hud_element_free(BattleMenu_TargetHudElems[i]);
            }
 
            // begin executing the move
            if (!(gBattleStatus.flags1 & BS_FLAGS1_PARTNER_ACTING)) {
                gBattleSubState = battleStatus->acceptTargetMenuSubstate;
                if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                    btl_state_update_peach_menu();
                } else {
                    btl_state_update_player_menu();
                }
                btl_set_state(BATTLE_STATE_PLAYER_MOVE);
            } else {
                gBattleSubState = battleStatus->acceptTargetMenuSubstate;
                if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                    btl_state_update_twink_menu();
                } else {
                    btl_state_update_partner_menu();
                }
                btl_set_state(BATTLE_STATE_PARTNER_MOVE);
            }
            break;
        case BTL_SUBSTATE_SELECT_TARGET_CANCEL:
            // free the HUD elements for the target pointers
            for (i = 0; i < targetListLength; i++) {
                hud_element_free(BattleMenu_TargetHudElems[i]);
            }
 
            gBattleStatus.flags1 |= BS_FLAGS1_10000 | BS_FLAGS1_MENU_OPEN;
            actor->flags |= ACTOR_FLAG_SHOW_STATUS_ICONS;
 
            if (battleStatus->itemUsesLeft != 0) {
                btl_set_state(BATTLE_STATE_PLAYER_MENU);
                gBattleSubState = battleStatus->cancelTargetMenuSubstate;
                if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                    btl_state_update_peach_menu();
                } else {
                    btl_state_update_player_menu();
                }
            } else if (!(gBattleStatus.flags1 & BS_FLAGS1_PARTNER_ACTING)) {
                btl_set_state(BATTLE_STATE_PLAYER_MENU);
                gBattleSubState = battleStatus->cancelTargetMenuSubstate;
                if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                    btl_state_update_peach_menu();
                } else {
                    btl_state_update_player_menu();
                }
            } else {
                btl_set_state(BATTLE_STATE_PARTNER_MENU);
                gBattleSubState = battleStatus->cancelTargetMenuSubstate;
                if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
                    btl_state_update_twink_menu();
                } else {
                    btl_state_update_partner_menu();
                }
            }
            break;
    }
}

Referenced by btl_update().

◆ btl_state_draw_select_target()

void btl_state_draw_select_target ( void )

Definition at line 5127 of file btl_states_menus.c.

                                        {
    BattleStatus* battleStatus = &gBattleStatus;
    PlayerData* playerData = &gPlayerData;
    s32 msgID;
    s32 msgX;
    s32 msgY;
    s32 targetListLength;
    s32 currentPartner;
    s32 actorID;
    SelectableTarget* target;
    Actor* choosingActor;
    Actor* enemyActor;
    s32 id;
    s32 i;
    s32 nameWidth;
    s32 xOffset, yOffset;
    f32 targetX, targetY, targetZ;
    s32 screenX, screenY, screenZ;
    s32 selectedTargetIndex;
    s8* targetIndexList;
    s32* tmpPtr; // TODO required to match and CURSED
 
    if (!(gBattleStatus.flags1 & BS_FLAGS1_PARTNER_ACTING)) {
        choosingActor = battleStatus->playerActor;
    } else {
        choosingActor = battleStatus->partnerActor;
    }
 
    targetListLength = choosingActor->targetListLength;
    target = choosingActor->targetData;
    selectedTargetIndex = choosingActor->selectedTargetIndex;
    targetIndexList = choosingActor->targetIndexList;
 
    tmpPtr = &BattleMenu_TargetNameOffsetX;
 
    if (targetListLength == 0) {
        return;
    }
 
    // draw target pointers
    if (battleStatus->curTargetListFlags & TARGET_FLAG_SELECT_ONE) {
        target = &choosingActor->targetData[targetIndexList[selectedTargetIndex]];
        enemyActor = get_actor(target->actorID);
        id = BattleMenu_TargetHudElems[0];
        targetX = target->truePos.x;
        targetY = target->truePos.y;
        targetZ = target->truePos.z;
 
        // select target pointer style based on target actor orientation
        if (enemyActor->flags & ACTOR_FLAG_UPSIDE_DOWN) {
            xOffset = 16;
            yOffset = 2;
            if (hud_element_get_script(id) != &HES_HandPointLeftLoop) {
                hud_element_set_script(id, &HES_HandPointLeftLoop);
            }
        } else {
            xOffset = 5;
            yOffset = -11;
            if (hud_element_get_script(id) != &HES_HandPointDownLoop) {
                hud_element_set_script(id, &HES_HandPointDownLoop);
            }
        }
 
        get_screen_coords(CAM_BATTLE, targetX, targetY, targetZ, &screenX, &screenY, &screenZ);
        hud_element_set_render_pos(id, screenX + xOffset, screenY + yOffset);
        hud_element_set_alpha(id, BattleMenu_TargetPointerAlpha);
    } else {
        for (i = 0; i < targetListLength; i++) {
            target = &choosingActor->targetData[targetIndexList[i]];
            enemyActor = get_actor(target->actorID);
            id = BattleMenu_TargetHudElems[i];
            targetX = target->truePos.x;
            targetY = target->truePos.y;
            targetZ = target->truePos.z;
 
            // select target pointer style based on target actor orientation
            if (enemyActor->flags & ACTOR_FLAG_UPSIDE_DOWN) {
                xOffset = 16;
                yOffset = 2;
                if (hud_element_get_script(id) != &HES_HandPointLeftLoop) {
                    hud_element_set_script(id, &HES_HandPointLeftLoop);
                }
            } else {
                xOffset = 5;
                yOffset = -11;
                if (hud_element_get_script(id) != &HES_HandPointDownLoop) {
                    hud_element_set_script(id, &HES_HandPointDownLoop);
                }
            }
 
            get_screen_coords(CAM_BATTLE, targetX, targetY, targetZ, &screenX, &screenY, &screenZ);
            hud_element_set_render_pos(id, screenX + xOffset, screenY + yOffset);
            hud_element_set_alpha(id, BattleMenu_TargetPointerAlpha);
        }
    }
 
    currentPartner = playerData->curPartner;
    screenX = 52;
    screenY = 64;
    if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
        currentPartner = PARTNER_TWINK;
    }
 
    // get target name width
    if ((battleStatus->curTargetListFlags & TARGET_FLAG_SELECT_ONE) || targetListLength == 1) {
        actorID = target->actorID;
        if (actorID == ACTOR_PLAYER) {
            nameWidth = get_msg_width(MSG_Menus_Battle_TargetMario, 0) + 10;
        } else if (actorID == ACTOR_PARTNER) {
            nameWidth = get_msg_width(PartnerNameMessages[currentPartner], 0) + 10;
        } else {
            target = &choosingActor->targetData[targetIndexList[selectedTargetIndex]];
            enemyActor = get_actor(target->actorID);
            msgID = get_actor_part(enemyActor, target->partID)->staticData->overrideNameMsg;
            if (msgID == MSG_NONE) {
                msgID = bActorNames[enemyActor->actorType];
            }
            nameWidth = get_msg_width(msgID, 0) + 10;
        }
    } else {
        target = &choosingActor->targetData[targetIndexList[selectedTargetIndex]];
        actorID = target->actorID;
        if (actorID == ACTOR_PLAYER) {
            nameWidth = get_msg_width(MSG_Menus_Battle_TargetMario, 0) + 10;
        } else if (actorID == ACTOR_PARTNER) {
            nameWidth = get_msg_width(PartnerNameMessages[currentPartner], 0) + 10;
        } else {
            nameWidth = get_msg_width(MSG_Menus_Battle_TargetAllEnemies, 0) + 10;
        }
    }
 
    // draw target name box
    draw_box(0, WINDOW_STYLE_4, screenX + BattleMenu_TargetNameOffsetX, screenY, 0, nameWidth, 20, 255, 0,
                0.0f, 0.0f, 0.0f, 0.0f, 0.0f, NULL, NULL, NULL, SCREEN_WIDTH, SCREEN_HEIGHT, NULL);
 
    // draw target name text
    screenX += 4;
    screenY += 2;
    if ((battleStatus->curTargetListFlags & TARGET_FLAG_SELECT_ONE) || targetListLength == 1) {
        actorID = target->actorID;
        if (actorID == ACTOR_PLAYER) {
            draw_msg(MSG_Menus_Battle_TargetMario, screenX + BattleMenu_TargetNameOffsetX, screenY, 255, MSG_PAL_36, 0);
        } else if (actorID == ACTOR_PARTNER) {
            draw_msg(PartnerNameMessages[currentPartner], screenX + BattleMenu_TargetNameOffsetX, screenY, 255, MSG_PAL_36, 0);
        } else {
            target = &choosingActor->targetData[targetIndexList[selectedTargetIndex]];
            enemyActor = get_actor(target->actorID);
            msgID = get_actor_part(enemyActor, target->partID)->staticData->overrideNameMsg;
            if (msgID == MSG_NONE) {
                msgID = bActorNames[enemyActor->actorType];
            }
            draw_msg(msgID, screenX + *tmpPtr, screenY, 255, MSG_PAL_36, 0); // TODO required to match
        }
    } else {
        target = &choosingActor->targetData[targetIndexList[selectedTargetIndex]];
        actorID = target->actorID;
        if (actorID == ACTOR_PLAYER) {
            draw_msg(MSG_Menus_Battle_TargetMario, screenX + BattleMenu_TargetNameOffsetX, screenY, 255, MSG_PAL_36, 0);
        } else if (actorID == ACTOR_PARTNER) {
            draw_msg(PartnerNameMessages[currentPartner], screenX + BattleMenu_TargetNameOffsetX, screenY, 255, MSG_PAL_36, 0);
        } else {
            draw_msg(MSG_Menus_Battle_TargetAllEnemies, screenX + BattleMenu_TargetNameOffsetX, screenY, 255, MSG_PAL_36, 0);
        }
    }
}

Referenced by btl_draw_ui().

◆ btl_state_update_22()

void btl_state_update_22 ( void )

Definition at line 5293 of file btl_states_menus.c.

5293 {

5294}

Referenced by btl_update().

◆ btl_state_draw_22()

void btl_state_draw_22 ( void )

Definition at line 5296 of file btl_states_menus.c.

5296 {

5297}

Referenced by btl_draw_ui().

◆ btl_state_update_celebration()

void btl_state_update_celebration ( void )

Definition at line 488 of file level_up.c.

                                        {
    BattleStatus* battleStatus = &gBattleStatus;
    PlayerData* playerData = &gPlayerData;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    s8 currentSubmenu;
    s32 newSubmenu;
    HudElemID hid;
    s32 x, y, z;
    s32 width;
    s32 itemHudElemID;
 
    Evt* takeTurnScript;
    Evt* script;
 
    s32 tensDigit;
    s32 onesDigit;
 
    s32 deltaSP;
    s32 prevSP;
 
    s32 i;
    s32 j;
 
    HudScript* new_var;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_CELEBRATE_INIT:
            if (battleStatus->pendingStarPoints <= 0) {
                player->flags &= ~ACTOR_FLAG_SHOW_STATUS_ICONS;
                EndBattleRewardTotal = battleStatus->totalStarPoints * 100;
                pendingLevelUps = 0;
                D_8029FB50 = 0;
                bFadeToBlackAmt = 0;
                LevelUpSelectTextOffsetX = 0;
                LevelUpSelectTextVelX = 0;
                sfx_play_sound(SOUND_JINGLE_WON_BATTLE);
 
                prevSP = playerData->starPoints + battleStatus->totalStarPoints;
                if (prevSP > 99) {
                    bgm_set_song(0, SONG_LEVEL_UP, 0, 250, 8);
                } else {
                    bgm_set_song(0, SONG_BATTLE_END, 0, 250, 8);
                }
 
                CelebrateStateTime = 0;
                btl_cam_use_preset(BTL_CAM_VICTORY);
                EndBattleRewardStep = 0;
                CelebrateSubstateTime = 1;
                gBattleSubState = BTL_SUBSTATE_CELEBRATE_LOAD_STAR_POINTS;
                gBattleStatus.flags2 |= BS_FLAGS2_AWARDING_STAR_POINTS;
            }
            break;
        case BTL_SUBSTATE_CELEBRATE_LOAD_STAR_POINTS:
            if (CelebrateSubstateTime != 0) {
                CelebrateSubstateTime--;
            } else if (btl_cam_is_moving_done()) {
                DMA_COPY_SEGMENT(starpoint);
                script = start_script(&EVS_ShowStarpoints, EVT_PRIORITY_A, 0);
                EndBattleRewardsDone = FALSE;
                // divide reward into 20 increments
                EndBattleRewardStep = 20;
                EndBattleRewardIncrement = EndBattleRewardTotal / EndBattleRewardStep;
                player->takeTurnScript = script;
                CelebrateSubstateTime = 1;
                player->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PLAYER;
                gBattleSubState = BTL_SUBSTATE_CELEBRATE_TALLY_STAR_POINTS;
            }
            break;
        case BTL_SUBSTATE_CELEBRATE_TALLY_STAR_POINTS:
            if (CelebrateSubstateTime == 0) {
                if (battleStatus->totalStarPoints != 0) {
                    // determine the remaining star point reward after this step and give the difference to the player
                    EndBattleRewardTotal -= EndBattleRewardIncrement;
                    prevSP = battleStatus->totalStarPoints;
                    battleStatus->totalStarPoints = EndBattleRewardTotal / 100;
                    deltaSP = prevSP - battleStatus->totalStarPoints;
                    if (deltaSP > 0) {
                        sfx_play_sound(SOUND_STAR_POINT_PICKUP);
                    }
 
                    playerData->starPoints += deltaSP;
                    bFadeToBlackAmt++; // ??
                    if (EndBattleRewardStep == 0 && battleStatus->totalStarPoints != 0) {
                        playerData->starPoints++;
                    }
                }
                if (playerData->level >= 27) {
                    playerData->starPoints = 0;
                }
                if (playerData->starPoints >= 100) {
                    pendingLevelUps = 1;
                    playerData->starPoints -= 100;
                }
                if (playerData->level + pendingLevelUps == 27) {
                    playerData->starPoints = 0;
                }
                if (battleStatus->totalStarPoints == 0) {
                    if (EndBattleRewardStep == 0) {
                        EndBattleRewardsDone = TRUE;
                        player->flags &= ~(ACTOR_FLAG_USING_IDLE_ANIM | ACTOR_FLAG_SHOW_STATUS_ICONS);
                        if (partner != NULL) {
                            partner->flags &= ~(ACTOR_FLAG_USING_IDLE_ANIM | ACTOR_FLAG_SHOW_STATUS_ICONS);
                        }
                        battleStatus->battlePhase = PHASE_CELEBRATE;
                        script = start_script(&EVS_Mario_HandlePhase, EVT_PRIORITY_A, 0);
                        player->takeTurnScript = script;
                        player->takeTurnScriptID = script->id;
                        script->owner1.actorID = ACTOR_PLAYER;
                        if (partner != NULL) {
                            script = start_script(partner->takeTurnSource, EVT_PRIORITY_A, 0);
                            partner->takeTurnScript = script;
                            partner->takeTurnScriptID = script->id;
                            script->owner1.actorID = ACTOR_PARTNER;
                        }
                        CelebrateSubstateTime = 40;
                        gBattleSubState = BTL_SUBSTATE_CELEBRATE_POST_STAR_POINTS;
                    } else {
                        EndBattleRewardStep--;
                    }
                }
            } else {
                CelebrateSubstateTime--;
            }
            break;
        case BTL_SUBSTATE_CELEBRATE_POST_STAR_POINTS:
            if (CelebrateSubstateTime == 0) {
                if (pendingLevelUps == 0) {
                    gBattleSubState = BTL_SUBSTATE_CELEBRATE_SKIPPABLE_END_DELAY;
                } else {
                    gBattleSubState = BTL_SUBSTATE_CELEBRATE_LEVEL_UP_LOAD;
                }
                break;
            }
            CelebrateSubstateTime--;
            break;
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_LOAD:
            if (CelebrateStateTime >= 99) {
                playerData->level++;
                btl_cam_use_preset(BTL_CAM_DEFAULT);
                btl_cam_move(5);
                DMA_COPY_SEGMENT(level_up);
                sfx_play_sound(SOUND_LOOP_CHEERING);
                CelebrateStateTime = 0;
                gBattleSubState = BTL_SUBSTATE_CELEBRATE_LEVEL_UP_BEGIN;
            }
            break;
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_BEGIN:
            LevelUpScriptPtr = start_script(&EVS_ShowLevelUp, EVT_PRIORITY_A, 0);
            LevelUpScriptID = LevelUpScriptPtr->id;
            CelebrateSubstateTime = 25;
            gBattleSubState = BTL_SUBSTATE_CELEBRATE_LEVEL_UP_CREATE_HUD;
            mdl_set_all_tint_type(ENV_TINT_SHROUD);
            *gBackgroundTintModePtr = ENV_TINT_SHROUD;
            mdl_set_shroud_tint_params(0, 0, 0, 0);
            break;
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_CREATE_HUD:
            if (CelebrateSubstateTime == 18) {
                playerData->curHP = playerData->curMaxHP;
                playerData->curFP = playerData->curMaxFP;
                x = player->curPos.x + 0.0f;
                y = player->curPos.y + 35.0f;
                z = player->curPos.z;
                fx_recover(0, x, y, z, playerData->curHP);
                x = player->curPos.x + 20.0f;
                y = player->curPos.y + 25.0f;
                z = player->curPos.z;
                fx_recover(1, x, y, z, playerData->curFP);
                playerData->starPower = playerData->maxStarPower * SP_PER_BAR;
            }
 
            if (CelebrateSubstateTime != 0) {
                CelebrateSubstateTime--;
                if (CelebrateSubstateTime < 10) {
                    mdl_set_shroud_tint_params(0, 0, 0, ((10 - CelebrateSubstateTime) * 16) & 0xF0);
                }
            } else {
                hid = hud_element_create(&HES_level_up_heart);
                LevelUpStatEmblemIDs[0] = hid;
                hud_element_set_render_pos(hid, 310, 140);
                hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
 
                hid = hud_element_create(&HES_level_up_flower);
                LevelUpStatEmblemIDs[1] = hid;
                hud_element_set_render_pos(hid, 158, 340);
                hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
 
                hid = hud_element_create(&HES_level_up_leaves);
                LevelUpStatEmblemIDs[3] = hid;
                hud_element_set_render_pos(hid, 158, 340);
                hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
 
                hid = hud_element_create(&HES_level_up_badge);
                LevelUpStatEmblemIDs[2] = hid;
                hud_element_set_render_pos(hid, 6, 140);
                hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
 
                hid = hud_element_create(levelup_stat_scripts[0]);
                LevelUpStatTextIDs[LVL_UP_FP][LVL_UP_TITLE] = hid;
                hud_element_set_render_pos(hid, 160, 317);
                hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
 
                for (i = 1; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_FP]); i++) {
                    hid = hud_element_create(HES_LevelUpDigits[LVL_UP_FP][0]);
                    LevelUpStatTextIDs[LVL_UP_FP][i] = hid;
                    hud_element_set_render_pos(hid, 160, 317);
                    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80 | HUD_ELEMENT_FLAG_DISABLED);
                }
 
                hid = hud_element_create(levelup_stat_scripts[1]);
                LevelUpStatTextIDs[LVL_UP_HP][LVL_UP_TITLE] = hid;
                hud_element_set_render_pos(hid, 312, 117);
                hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
 
                for (i = 1; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_HP]); i++) {
                    hid = hud_element_create(HES_LevelUpDigits[LVL_UP_HP][0]);
                    LevelUpStatTextIDs[LVL_UP_HP][i] = hid;
                    hud_element_set_render_pos(hid, 312, 117);
                    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80 | HUD_ELEMENT_FLAG_DISABLED);
                }
 
                hid = hud_element_create(levelup_stat_scripts[2]);
                LevelUpStatTextIDs[LVL_UP_BP][LVL_UP_TITLE] = hid;
                hud_element_set_render_pos(hid, 8, 117);
                hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
 
                for (i = 1; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_BP]); i++) {
                    hid = hud_element_create(HES_LevelUpDigits[LVL_UP_BP][0]);
                    LevelUpStatTextIDs[LVL_UP_BP][i] = hid;
                    hud_element_set_render_pos(hid, 8, 117);
                    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80 | HUD_ELEMENT_FLAG_DISABLED);
                }
 
                CantLevelUpStat[MENU_HP] = FALSE;
                CantLevelUpStat[MENU_FP] = FALSE;
                CantLevelUpStat[MENU_BP] = FALSE;
 
                if (playerData->hardMaxFP != 50) {
                    // current FP
                    tensDigit = playerData->curMaxFP / 10;
                    onesDigit = playerData->curMaxFP % 10;
                    hid = LevelUpStatTextIDs[LVL_UP_FP][LVL_UP_CUR_TENS];
                    hud_element_set_script(hid, level_up_small_digit_scripts[LVL_UP_FP][tensDigit]);
                    if (tensDigit != 0) {
                        hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    }
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 14, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_FP][LVL_UP_CUR_ONES];
                    hud_element_set_script(hid, level_up_small_digit_scripts[LVL_UP_FP][onesDigit]);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 8, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_FP][LVL_UP_ARROW];
                    hud_element_set_script(hid, &HES_level_up_small_green_arrow);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 3, y + 46);
 
                    // upgraded FP
                    tensDigit = (playerData->curMaxFP + 5) / 10;
                    onesDigit = (playerData->curMaxFP + 5) % 10;
                    hid = LevelUpStatTextIDs[LVL_UP_FP][LVL_UP_NEXT_TENS];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_FP][tensDigit]);
                    if (tensDigit != 0) {
                        hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    }
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 3, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_FP][LVL_UP_NEXT_ONES];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_FP][onesDigit]);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 10, y + 46);
                } else {
                    // upgraded FP only
                    hid = LevelUpStatTextIDs[LVL_UP_FP][LVL_UP_NEXT_TENS];
                    tensDigit = playerData->curMaxFP / 10;
                    onesDigit = playerData->curMaxFP % 10;
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_FP][tensDigit]);
                    if (tensDigit != 0) {
                        hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    }
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 6, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_FP][LVL_UP_NEXT_ONES];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_FP][onesDigit]);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 2, y + 46);
                    CantLevelUpStat[MENU_FP] = TRUE;
                }
 
                if (is_ability_active(ABILITY_FP_PLUS)) {
                    hid = LevelUpStatTextIDs[LVL_UP_FP][LVL_UP_BONUS];
                    itemHudElemID = gItemTable[ITEM_FP_PLUS_A].hudElemID;
                    hud_element_set_script(hid, gItemHudScripts[itemHudElemID].enabled);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_set_scale(hid, 0.5f);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 17, y + 46);
                }
 
                if (playerData->hardMaxHP != 50) {
                    // current HP
                    tensDigit = playerData->curMaxHP / 10;
                    onesDigit = playerData->curMaxHP % 10;
 
                    hid = LevelUpStatTextIDs[LVL_UP_HP][LVL_UP_CUR_TENS];
                    hud_element_set_script(hid, level_up_small_digit_scripts[LVL_UP_HP][tensDigit]);
                    if (tensDigit != 0) {
                        hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    }
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 14, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_HP][LVL_UP_CUR_ONES];
                    hud_element_set_script(hid, level_up_small_digit_scripts[LVL_UP_HP][onesDigit]);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 8, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_HP][LVL_UP_ARROW];
                    hud_element_set_script(hid, &HES_level_up_small_red_arrow);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 3, y + 46);
 
                    tensDigit = (playerData->curMaxHP + 5) / 10;
                    onesDigit = (playerData->curMaxHP + 5) % 10;
 
                    hid = LevelUpStatTextIDs[LVL_UP_HP][LVL_UP_NEXT_TENS];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_HP][tensDigit]);
                    if (tensDigit != 0) {
                        hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    }
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 3, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_HP][LVL_UP_NEXT_ONES];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_HP][onesDigit]);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 10, y + 46);
                } else {
                    tensDigit = playerData->curMaxHP / 10;
                    onesDigit = playerData->curMaxHP % 10;
 
                    hid = LevelUpStatTextIDs[LVL_UP_HP][LVL_UP_NEXT_TENS];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_HP][tensDigit]);
                    if (tensDigit != 0) {
                        hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    }
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 6, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_HP][LVL_UP_NEXT_ONES];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_HP][onesDigit]);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 2, y + 46);
                    CantLevelUpStat[MENU_HP] = TRUE;
                }
 
                if (is_ability_active(ABILITY_HP_PLUS)) {
                    hid = LevelUpStatTextIDs[LVL_UP_HP][LVL_UP_BONUS];
                    itemHudElemID = gItemTable[ITEM_HP_PLUS_A].hudElemID;
                    hud_element_set_script(hid, gItemHudScripts[itemHudElemID].enabled);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_set_scale(hid, 0.5f);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 17, y + 46);
                }
 
                if (playerData->maxBP != 30) {
                    tensDigit = playerData->maxBP / 10;
                    onesDigit = playerData->maxBP % 10;
 
                    hid = LevelUpStatTextIDs[LVL_UP_BP][LVL_UP_CUR_TENS];
                    hud_element_set_script(hid, level_up_small_digit_scripts[LVL_UP_BP][tensDigit]);
                    if (tensDigit != 0) {
                        hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    }
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 14, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_BP][LVL_UP_CUR_ONES];
                    hud_element_set_script(hid, level_up_small_digit_scripts[LVL_UP_BP][onesDigit]);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 8, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_BP][LVL_UP_ARROW];
                    hud_element_set_script(hid, &HES_level_up_small_blue_arrow);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 3, y + 46);
 
                    tensDigit = (playerData->maxBP + 3) / 10;
                    onesDigit = (playerData->maxBP + 3) % 10;
 
                    hid = LevelUpStatTextIDs[LVL_UP_BP][LVL_UP_NEXT_TENS];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_BP][tensDigit]);
                    if (tensDigit != 0) {
                        hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    }
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 3, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_BP][LVL_UP_NEXT_ONES];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_BP][onesDigit]);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 10, y + 46);
                } else {
                    hid = LevelUpStatTextIDs[LVL_UP_BP][LVL_UP_NEXT_TENS];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_BP][3]);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x - 6, y + 46);
 
                    hid = LevelUpStatTextIDs[LVL_UP_BP][LVL_UP_NEXT_ONES];
                    hud_element_set_script(hid, HES_LevelUpDigits[LVL_UP_BP][0]);
                    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_DISABLED);
                    hud_element_get_render_pos(hid, &x, &y);
                    hud_element_set_render_pos(hid, x + 2, y + 46);
                    CantLevelUpStat[MENU_BP] = TRUE;
                }
 
                LevelUpSpotlightID = hid = hud_element_create(&HES_ProjectorBeam);
                hud_element_create_transform_B(hid);
                hud_element_set_render_pos(hid, 156, 13);
                hud_element_set_tint(hid, 255, 255, 255);
                hud_element_set_transform_rotation_pivot(hid, 0, -35);
                hud_element_set_transform_rotation(hid, 0.0f, 0.0f, 180.0f);
                hud_element_set_transform_scale(hid, 1.0f, 1.5f, 1.0f);
                hud_element_set_alpha(hid, 200);
                hud_element_set_flags(hid, HUD_ELEMENT_FLAG_FILTER_TEX | HUD_ELEMENT_FLAG_80);
 
                LevelUpSelectTextID = hid = hud_element_create(&HES_level_up_select_one_to_upgrade);
                hud_element_set_render_pos(hid, 0, 0);
                hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
                battleStatus->curSubmenu = 1;
 
                CelebrateSubstateTime = 10;
                gBattleSubState = BTL_SUBSTATE_CELEBRATE_LEVEL_UP_SHOW_HUD;
            }
            break;
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_SHOW_HUD:
            hid = LevelUpStatEmblemIDs[0];
            hud_element_get_render_pos(hid, &x, &y);
            x -= 20;
            hud_element_set_render_pos(hid, x, y);
 
            for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_HP]); i++) {
                hid = LevelUpStatTextIDs[LVL_UP_HP][i];
                hud_element_get_render_pos(hid, &x, &y);
                x -= 20;
                hud_element_set_render_pos(hid, x, y);
            }
 
            hid = LevelUpStatEmblemIDs[1];
            hud_element_get_render_pos(hid, &x, &y);
            y -= 20;
            hud_element_set_render_pos(hid, x, y);
 
            hid = LevelUpStatEmblemIDs[3];
            hud_element_get_render_pos(hid, &x, &y);
            y -= 20;
            hud_element_set_render_pos(hid, x, y);
 
            for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_FP]); i++) {
                hid = LevelUpStatTextIDs[LVL_UP_FP][i];
                hud_element_get_render_pos(hid, &x, &y);
                y -= 20;
                hud_element_set_render_pos(hid, x, y);
            }
 
            hid = LevelUpStatEmblemIDs[2];
            hud_element_get_render_pos(hid, &x, &y);
            x += 20;
            hud_element_set_render_pos(hid, x, y);
 
            for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_BP]); i++) {
                hid = LevelUpStatTextIDs[LVL_UP_BP][i];
                hud_element_get_render_pos(hid, &x, &y);
                x += 20;
                hud_element_set_render_pos(hid, x, y);
            }
 
            CelebrateSubstateTime--;
            if (CelebrateSubstateTime == 0) {
                hud_element_set_tint(hid, 128, 128, 128);
#if VERSION_JP
                x = 32;
                y = 186;
                set_window_properties(WIN_BTL_DESC_BOX, 32, 186, 242, 32, WINDOW_PRIORITY_20, draw_content_level_up_textbox, NULL, -1);
#else
                x = 20;
                y = 186;
                set_window_properties(WIN_BTL_DESC_BOX, 20, 186, 280, 32, WINDOW_PRIORITY_20, draw_content_level_up_textbox, NULL, -1);
#endif
                set_window_update(WIN_BTL_DESC_BOX, WINDOW_UPDATE_SHOW);
                gBattleSubState = BTL_SUBSTATE_CELEBRATE_LEVEL_UP_CHOOSE;
            }
            break;
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_CHOOSE:
            if (battleStatus->curButtonsPressed & BUTTON_A) {
                if (!CantLevelUpStat[battleStatus->curSubmenu]) {
                    sfx_play_sound(SOUND_MENU_NEXT);
                    sfx_play_sound(SOUND_LRAW_CHEERING | SOUND_ID_TRIGGER_CHANGE_SOUND);
                    gBattleSubState = BTL_SUBSTATE_CELEBRATE_LEVEL_UP_UPGRADE;
                } else {
                    sfx_play_sound(SOUND_MENU_ERROR);
                    gBattleSubState = BTL_SUBSTATE_CELEBRATE_LEVEL_UP_INVALID;
                }
                break;
            }
 
            newSubmenu = currentSubmenu = battleStatus->curSubmenu;
            if (battleStatus->curButtonsHeld & BUTTON_STICK_LEFT) {
                newSubmenu--;
            }
            if (battleStatus->curButtonsHeld & BUTTON_STICK_RIGHT) {
                newSubmenu++;
            }
            if (newSubmenu < 0) {
                newSubmenu = 0;
            }
            if (newSubmenu > 2) {
                newSubmenu = 2;
            }
            if (newSubmenu != currentSubmenu) {
                sfx_play_sound(SOUND_MENU_CHANGE_SELECTION);
                battleStatus->curSubmenu = newSubmenu;
            }
 
            CelebrateStateTime++;
            if (CelebrateStateTime > 100) {
                fx_confetti(3, 0.0f, 100.0f, 0.0f, 1.0f, 120);
                CelebrateStateTime = 0;
            }
            break;
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_UPGRADE:
            hud_element_free(LevelUpSpotlightID);
            set_window_update(WIN_BTL_DESC_BOX, WINDOW_UPDATE_HIDE);
 
            switch (battleStatus->curSubmenu) {
                case 0:
                    playerData->hardMaxHP += 5;
                    playerData->curMaxHP += 5;
                    playerData->curHP += 5;
                    if (playerData->curMaxHP > 75) {
                        playerData->curMaxHP = 75;
                    }
                    if (playerData->curHP > playerData->curMaxHP) {
                        playerData->curHP = playerData->curMaxHP;
                    }
                    player->maxHP = playerData->curMaxHP;
                    player->curHP = playerData->curHP;
                    break;
                case 1:
                    playerData->hardMaxFP += 5;
                    playerData->curMaxFP += 5;
                    playerData->curFP += 5;
                    if (playerData->curMaxFP > 75) {
                        playerData->curMaxFP = 75;
                    }
                    if (playerData->curFP > playerData->curMaxFP) {
                        playerData->curFP = playerData->curMaxFP;
                    }
                    break;
                case 2:
                    playerData->maxBP += 3;
                    if (playerData->maxBP > 30) {
                        playerData->maxBP = 30;
                    }
                    break;
            }
 
            set_actor_anim(0, 0, ANIM_MarioB1_AdjustCap);
 
            if (partner != NULL) {
                script = start_script(partner->takeTurnSource, EVT_PRIORITY_A, 0);
                partner->takeTurnScript = script;
                partner->takeTurnScriptID = script->id;
                script->owner1.actorID = ACTOR_PARTNER;
            }
            if (!(gBattleStatus.flags2 & BS_FLAGS2_DONT_STOP_MUSIC)) {
                bgm_set_song(0, -1, 0, 2000, 8);
            }
            bFadeToBlackAmt = 0;
            gBattleSubState = BTL_SUBSTATE_CELEBRATE_LEVEL_UP_FADE_OUT;
            break;
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_FADE_OUT:
            if ((gGameStatusPtr->frameCounter % 2) != 0) {
                switch (battleStatus->curSubmenu) {
                    case 0:
                        hud_element_set_flags(LevelUpStatEmblemIDs[0], HUD_ELEMENT_FLAG_DISABLED);
                        break;
                    case 1:
                        hud_element_set_flags(LevelUpStatEmblemIDs[1], HUD_ELEMENT_FLAG_DISABLED);
                        hud_element_set_flags(LevelUpStatEmblemIDs[3], HUD_ELEMENT_FLAG_DISABLED);
                        break;
                    case 2:
                        hud_element_set_flags(LevelUpStatEmblemIDs[2], HUD_ELEMENT_FLAG_DISABLED);
                        break;
                }
            } else {
                switch (battleStatus->curSubmenu) {
                    case 0:
                        hud_element_clear_flags(LevelUpStatEmblemIDs[0], HUD_ELEMENT_FLAG_DISABLED);
                        break;
                    case 1:
                        hud_element_clear_flags(LevelUpStatEmblemIDs[1], HUD_ELEMENT_FLAG_DISABLED);
                        hud_element_clear_flags(LevelUpStatEmblemIDs[3], HUD_ELEMENT_FLAG_DISABLED);
                        break;
                    case 2:
                        hud_element_clear_flags(LevelUpStatEmblemIDs[2], HUD_ELEMENT_FLAG_DISABLED);
                        break;
                }
            }
            if (bFadeToBlackAmt == 255) {
                gBattleSubState = BTL_SUBSTATE_CELEBRATE_LEVEL_UP_DESTROY_HUD;
                break;
            }
            bFadeToBlackAmt += 10;
            if (bFadeToBlackAmt > 255) {
                bFadeToBlackAmt = 255;
            }
            break;
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_DESTROY_HUD:
            hud_element_free(LevelUpStatEmblemIDs[0]);
            hud_element_free(LevelUpStatEmblemIDs[1]);
            hud_element_free(LevelUpStatEmblemIDs[3]);
            hud_element_free(LevelUpStatEmblemIDs[2]);
 
            for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs); i++) {
                for (j = 0; j < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_FP]); j++) {
                    hud_element_free(LevelUpStatTextIDs[i][j]);
                }
            }
 
            hud_element_free(LevelUpSelectTextID);
            mdl_set_shroud_tint_params(0, 0, 0, 0);
            btl_set_state(BATTLE_STATE_END_BATTLE);
            gBattleSubState = BTL_SUBSTATE_END_BATTLE_EXEC_STAGE_SCRIPT;
            break;
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_INVALID:
            width = get_msg_width(MSG_Menus_CantIncrease, 0) + 31;
            x = 160 - (width / 2);
            y = 80;
            set_window_properties(WIN_BTL_POPUP, x, y, width, 28, WINDOW_PRIORITY_10, draw_content_cant_increase_popup, NULL, -1);
            set_window_update(WIN_BTL_POPUP, WINDOW_UPDATE_SHOW);
            CelebrateSubstateTime = 60;
            gBattleSubState = BTL_SUBSTATE_CELEBRATE_LEVEL_UP_INVALID_DELAY;
            break;
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_INVALID_DELAY:
            if (gGameStatusPtr->pressedButtons[0] & (BUTTON_A | BUTTON_B)) {
                CelebrateSubstateTime = 0;
            }
            if (CelebrateSubstateTime != 0) {
                CelebrateSubstateTime--;
                break;
            }
            set_window_update(WIN_BTL_POPUP, WINDOW_UPDATE_HIDE);
            gBattleSubState = BTL_SUBSTATE_CELEBRATE_LEVEL_UP_CHOOSE;
            break;
        case BTL_SUBSTATE_CELEBRATE_SKIPPABLE_END_DELAY:
            if (battleStatus->curButtonsPressed & (BUTTON_A | BUTTON_B)) {
                CelebrateStateTime = 99;
#if VERSION_JP
                sfx_play_sound(SOUND_MENU_NEXT);
#endif
            }
            if (CelebrateStateTime >= 99) {
                if (!(gBattleStatus.flags2 & BS_FLAGS2_DONT_STOP_MUSIC)) {
                    bgm_set_song(0, -1, 0, 1500, 8);
                }
                bFadeToBlackAmt = 0;
                btl_cam_set_params(TRUE, 270, 100, 8, 0, 0x2400, 100);
                set_actor_anim(0, 0, ANIM_MarioB1_AdjustCap);
                if (partner != NULL) {
                    set_actor_anim(ACTOR_PARTNER, 0, D_80284154[playerData->curPartner]);
                }
                CelebrateSubstateTime = 6;
                gBattleSubState = BTL_SUBSTATE_CELEBRATE_WALK_AWAY;
                break;
            }
            break;
        case BTL_SUBSTATE_CELEBRATE_WALK_AWAY:
            if (CelebrateSubstateTime != 0) {
                CelebrateSubstateTime--;
                if (CelebrateSubstateTime == 0) {
                    set_actor_anim(0, 0, ANIM_Mario1_Walk);
                }
            } else {
                player->yaw = 0.0f;
                if (partner != NULL) {
                    partner->yaw = 0.0f;
                }
 
                player->curPos.x += 4.0f;
                if (partner != NULL) {
                    partner->curPos.x += 4.0f;
                }
            }
            if (bFadeToBlackAmt == 255) {
                gBattleSubState = BTL_SUBSTATE_CELEBRATE_DONE;
                break;
            }
            bFadeToBlackAmt += 20;
            if (bFadeToBlackAmt > 255) {
                bFadeToBlackAmt = 255;
            }
            break;
        case BTL_SUBSTATE_CELEBRATE_DONE:
            if (does_script_exist(player->takeTurnScriptID)) {
                kill_script_by_ID(player->takeTurnScriptID);
            }
            if (partner != NULL && does_script_exist(partner->takeTurnScriptID)) {
                kill_script_by_ID(partner->takeTurnScriptID);
            }
            btl_set_state(BATTLE_STATE_END_BATTLE);
            gBattleSubState = BTL_SUBSTATE_END_BATTLE_EXEC_STAGE_SCRIPT;
            break;
    }
    CelebrateStateTime++;
}

Referenced by btl_update().

◆ btl_draw_upgrade_windows()

void btl_draw_upgrade_windows ( s32 phase )

Definition at line 1223 of file level_up.c.

                                         {
    BattleStatus* battleStatus = &gBattleStatus;
    s32 x;
    s32 y;
    s32 d1;
    s32 d2;
    s32 d3;
 
    switch (phase) {
        case 0: // before choice
            d1 = 100;
            d2 = 100;
            d3 = 100;
            break;
        case 1: // choosing
            switch (battleStatus->curSubmenu) {
                case MENU_HP:
                    d1 = 0;
                    d2 = 100;
                    d3 = 100;
                    break;
                case MENU_FP:
                    d1 = 100;
                    d2 = 0;
                    d3 = 100;
                    break;
                default:
                    d1 = 100;
                    d2 = 100;
                    d3 = 0;
                    break;
            }
            break;
        default: // after choice
            d1 = 100;
            d2 = 100;
            d3 = 100;
            break;
    }
 
    hud_element_get_render_pos(LevelUpStatEmblemIDs[0], &x, &y);
    draw_box(0, WINDOW_STYLE_15, x - 22, y - 22, 0, 44, 44, 255, d1, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, NULL, NULL, NULL,
             SCREEN_WIDTH, SCREEN_HEIGHT, NULL);
    hud_element_get_render_pos(LevelUpStatEmblemIDs[3], &x, &y);
    draw_box(0, WINDOW_STYLE_15, x - 22, y - 22, 0, 44, 44, 255, d2, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, NULL, NULL, NULL,
             SCREEN_WIDTH, SCREEN_HEIGHT, NULL);
    hud_element_get_render_pos(LevelUpStatEmblemIDs[2], &x, &y);
    draw_box(0, WINDOW_STYLE_15, x - 22, y - 22, 0, 44, 44, 255, d3, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, NULL, NULL, NULL,
             SCREEN_WIDTH, SCREEN_HEIGHT, NULL);
}

Referenced by btl_state_draw_celebration().

◆ btl_state_draw_celebration()

void btl_state_draw_celebration ( void )

Definition at line 1274 of file level_up.c.

                                      {
    BattleStatus* battleStatus = &gBattleStatus;
    s32 rotZ;
    s32 id;
    s32 i;
    s32 j;
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_SHOW_HUD:
            btl_draw_upgrade_windows(0);
            id = LevelUpStatEmblemIDs[0];
            hud_element_set_tint(id, 128, 128, 128);
            hud_element_draw_clipped(id);
            id = LevelUpStatEmblemIDs[3];
            hud_element_set_tint(id, 128, 128, 128);
            hud_element_draw_clipped(id);
            id = LevelUpStatEmblemIDs[1];
            hud_element_set_tint(id, 128, 128, 128);
            hud_element_draw_clipped(id);
            id = LevelUpStatEmblemIDs[2];
            hud_element_set_tint(id, 128, 128, 128);
            hud_element_draw_clipped(id);
 
            for (j = 0; j < ARRAY_COUNT(LevelUpStatTextIDs); j++) {
                for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_FP]); i++) {
                    id = LevelUpStatTextIDs[j][i];
 
                    hud_element_set_tint(id, 128, 128, 128);
                    hud_element_draw_clipped(id);
                }
            }
            break;
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_CHOOSE:
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_INVALID:
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_INVALID_DELAY:
            switch (battleStatus->curSubmenu) {
                case 0:
                    rotZ = 152;
                    hud_element_set_tint(LevelUpStatEmblemIDs[0], 255, 255, 255);
                    hud_element_set_tint(LevelUpStatEmblemIDs[3], 128, 128, 128);
                    hud_element_set_tint(LevelUpStatEmblemIDs[1], 128, 128, 128);
                    hud_element_set_tint(LevelUpStatEmblemIDs[2], 128, 128, 128);
 
                    for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_FP]); i++) {
                        id = LevelUpStatTextIDs[LVL_UP_FP][i];
 
                        hud_element_set_tint(id, 128, 128, 128);
                    }
 
                    for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_HP]); i++) {
                        id = LevelUpStatTextIDs[LVL_UP_HP][i];
 
                        hud_element_set_tint(id, 255, 255, 255);
                    }
 
                    for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_BP]); i++) {
                        id = LevelUpStatTextIDs[LVL_UP_BP][i];
 
                        hud_element_set_tint(id, 128, 128, 128);
                    }
 
                    id = LevelUpStatEmblemIDs[0];
                    if (hud_element_get_script(id) != &HES_level_up_heart_copy) {
                        hud_element_set_script(id, &HES_level_up_heart_copy);
                    }
                    id = LevelUpStatEmblemIDs[3];
                    if (hud_element_get_script(id) != &HES_level_up_leaves) {
                        hud_element_set_script(id, &HES_level_up_leaves);
                    }
                    id = LevelUpStatEmblemIDs[1];
                    if (hud_element_get_script(id) != &HES_level_up_flower) {
                        hud_element_set_script(id, &HES_level_up_flower);
                    }
                    id = LevelUpStatEmblemIDs[2];
                    if (hud_element_get_script(id) != &HES_level_up_badge) {
                        hud_element_set_script(id, &HES_level_up_badge);
                    }
                    break;
                case 1:
                    rotZ = 180;
                    hud_element_set_tint(LevelUpStatEmblemIDs[0], 128, 128, 128);
                    hud_element_set_tint(LevelUpStatEmblemIDs[3], 255, 255, 255);
                    hud_element_set_tint(LevelUpStatEmblemIDs[1], 255, 255, 255);
                    hud_element_set_tint(LevelUpStatEmblemIDs[2], 128, 128, 128);
 
                    for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_FP]); i++) {
                        id = LevelUpStatTextIDs[LVL_UP_FP][i];
 
                        hud_element_set_tint(id, 255, 255, 255);
                    }
 
                    for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_HP]); i++) {
                        id = LevelUpStatTextIDs[LVL_UP_HP][i];
 
                        hud_element_set_tint(id, 128, 128, 128);
                    }
 
                    for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_BP]); i++) {
                        id = LevelUpStatTextIDs[LVL_UP_BP][i];
 
                        hud_element_set_tint(id, 128, 128, 128);
                    }
                    break;
                case 2:
                default:
                    rotZ = 208;
                    hud_element_set_tint(LevelUpStatEmblemIDs[0], 128, 128, 128);
                    hud_element_set_tint(LevelUpStatEmblemIDs[3], 128, 128, 128);
                    hud_element_set_tint(LevelUpStatEmblemIDs[1], 128, 128, 128);
                    hud_element_set_tint(LevelUpStatEmblemIDs[2], 255, 255, 255);
 
                    for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_FP]); i++) {
                        id = LevelUpStatTextIDs[LVL_UP_FP][i];
 
                        hud_element_set_tint(id, 128, 128, 128);
                    }
 
                    for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_HP]); i++) {
                        id = LevelUpStatTextIDs[LVL_UP_HP][i];
 
                        hud_element_set_tint(id, 128, 128, 128);
                    }
 
                    for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_BP]); i++) {
                        id = LevelUpStatTextIDs[LVL_UP_BP][i];
 
                        hud_element_set_tint(id, 255, 255, 255);
                    }
                    break;
            }
 
            btl_draw_upgrade_windows(1);
            hud_element_draw_clipped(LevelUpStatEmblemIDs[0]);
            hud_element_draw_clipped(LevelUpStatEmblemIDs[3]);
            hud_element_draw_clipped(LevelUpStatEmblemIDs[1]);
            hud_element_draw_clipped(LevelUpStatEmblemIDs[2]);
 
            for (j = 0; j < ARRAY_COUNT(LevelUpStatTextIDs); j++) {
                for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_FP]); i++) {
                    hud_element_draw_clipped(LevelUpStatTextIDs[j][i]);
                }
            }
 
            func_80144218(-1);
            id = LevelUpSpotlightID;
            hud_element_set_transform_rotation(id, 0.0f, 0.0f, rotZ);
            func_80144238(id);
            break;
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_UPGRADE:
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_FADE_OUT:
            btl_draw_upgrade_windows(1);
            hud_element_draw_clipped(LevelUpStatEmblemIDs[0]);
            hud_element_draw_clipped(LevelUpStatEmblemIDs[3]);
            hud_element_draw_clipped(LevelUpStatEmblemIDs[1]);
            hud_element_draw_clipped(LevelUpStatEmblemIDs[2]);
 
            for (j = 0; j < ARRAY_COUNT(LevelUpStatTextIDs); j++) {
                for (i = 0; i < ARRAY_COUNT(LevelUpStatTextIDs[LVL_UP_FP]); i++) {
                    hud_element_draw_clipped(LevelUpStatTextIDs[j][i]);
                }
            }
 
            set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, bFadeToBlackAmt);
            break;
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_DESTROY_HUD:
            set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, bFadeToBlackAmt);
            break;
        case BTL_SUBSTATE_CELEBRATE_WALK_AWAY:
            if (bFadeToBlackAmt != 0) {
                set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, bFadeToBlackAmt);
            }
            break;
    }
 
    switch (gBattleSubState) {
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_SHOW_HUD:
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_CHOOSE:
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_UPGRADE:
            LevelUpSelectTextVelX += 2;
            LevelUpSelectTextOffsetX += LevelUpSelectTextVelX;
            if (LevelUpSelectTextOffsetX > 200) {
                LevelUpSelectTextOffsetX = 200;
                LevelUpSelectTextVelX = -LevelUpSelectTextVelX / 3; // rebounding
            }
            id = LevelUpSelectTextID;
            hud_element_set_render_pos(id, LevelUpSelectTextOffsetX - 43, 176);
            hud_element_draw_clipped(id);
            break;
        case BTL_SUBSTATE_CELEBRATE_LEVEL_UP_FADE_OUT:
            LevelUpSelectTextVelX += 4;
            LevelUpSelectTextOffsetX += LevelUpSelectTextVelX;
            if (LevelUpSelectTextOffsetX > 500) {
                LevelUpSelectTextOffsetX = 500;
            }
            id = LevelUpSelectTextID;
            hud_element_set_render_pos(id, LevelUpSelectTextOffsetX - 43, 176);
            hud_element_draw_clipped(id);
            break;
    }
}

Referenced by btl_draw_ui().

◆ btl_bonk_cleanup()

void btl_bonk_cleanup ( void )

Definition at line 536 of file popup_messages.c.

                            {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(popupMessages); i++) {
        PopupMessage* popup = &popupMessages[i];
 
        if (popup->active != 0 && (popup->active & 0x10)) {
            BonkData* bonkData = popup->data.bonk;
            s32 j;
 
            for (j = 0; j < popup->messageIndex; j++, bonkData++) {
                if (bonkData->alive) {
                    bonkData->startupTime = 0;
                    bonkData->moveTime = 1;
                    bonkData->holdTime = 20;
                }
            }
        }
    }
}

Referenced by btl_update().

◆ set_actor_anim_by_ref()

void set_actor_anim_by_ref	(	Actor *	actor,
		ActorPart *	part,
		AnimID	anim )

Definition at line 1047 of file 190B20.c.

                                                                       {
    if ((s32) anim >= 0) {
        switch (actor->actorID & ACTOR_CLASS_MASK) {
            case ACTOR_CLASS_PLAYER:
                if (part->curAnimation != anim) {
                    part->curAnimation = anim;
                    spr_update_player_sprite(PLAYER_SPRITE_MAIN, anim, part->animationRate);
                }
                break;
            case ACTOR_CLASS_PARTNER:
            case ACTOR_CLASS_ENEMY:
                if (part->curAnimation != anim) {
                    part->curAnimation = anim;
                    spr_update_sprite(part->spriteInstanceID, anim, part->animationRate);
                    part->animNotifyValue = spr_get_notify_value(part->spriteInstanceID);
                }
                break;
        }
    }
}

◆ update_action_ratings()

void update_action_ratings ( void )

Definition at line 2443 of file 190B20.c.

                                 {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* actor;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
        actor = gBattleStatus.enemyActors[i];
        if (actor != NULL) {
            if (actor->actionRatingTime == 60) {
                if (actor->attackResultEffect != NULL) {
                    actor->attackResultEffect->data.attackResultText->isVisible = FALSE;
                }
            }
            if (actor->actionRatingTime == 5) {
                if (actor->attackResultEffect != NULL) {
                    actor->attackResultEffect->data.attackResultText->timeLeft = 0;
                    actor->attackResultEffect = NULL;
                }
            }
            if (actor->actionRatingTime > 0) {
                actor->actionRatingTime--;
            }
        }
    }
 
    actor = battleStatus->playerActor;
    if (actor != NULL) {
        if (actor->actionRatingTime == 60) {
            if (actor->attackResultEffect != NULL) {
                actor->attackResultEffect->data.attackResultText->isVisible = FALSE;
            }
        }
        if (actor->actionRatingTime == 5) {
            if (actor->attackResultEffect != NULL) {
                actor->attackResultEffect->data.attackResultText->timeLeft = 0;
                actor->attackResultEffect = NULL;
            }
        }
        if (actor->actionRatingTime > 0) {
            actor->actionRatingTime--;
        }
    }
 
    actor = battleStatus->partnerActor;
    if (actor != NULL) {
        if (actor->actionRatingTime == 60) {
            if (actor->attackResultEffect != NULL) {
                actor->attackResultEffect->data.attackResultText->isVisible = FALSE;
            }
        }
        if (actor->actionRatingTime == 5) {
            if (actor->attackResultEffect != NULL) {
                actor->attackResultEffect->data.attackResultText->timeLeft = 0;
                actor->attackResultEffect = NULL;
            }
        }
        if (actor->actionRatingTime > 0) {
            actor->actionRatingTime--;
        }
    }
}

Referenced by btl_update().

◆ update_health_bars()

void update_health_bars ( void )

Definition at line 2515 of file 190B20.c.

                              {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gBattleStatus.enemyActors); i++) {
        Actor* enemy = gBattleStatus.enemyActors[i];
 
        if (enemy != NULL) {
            if (enemy->healthBarHideTime > 0) {
                enemy->healthBarHideTime--;
                if (enemy->healthBarHideTime == 0) {
                    enemy->flags &= ~ACTOR_FLAG_HEALTH_BAR_HIDDEN;
                }
            }
        }
    }
}

Referenced by btl_update().

◆ btl_cam_is_moving_done()

s32 btl_cam_is_moving_done ( void )

Definition at line 1980 of file camera.c.

                                 {
    return BattleCam_DoneMoving;
}

Referenced by btl_state_update_begin_partner_turn(), btl_state_update_begin_player_turn(), and btl_state_update_celebration().

◆ btl_popup_messages_update()

void btl_popup_messages_update ( void )

Definition at line 294 of file popup_messages.c.

                                     {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(popupMessages); i++) {
        PopupMessage* popup = &popupMessages[i];
        if (popup->active && popup->updateFunc != NULL) {
            popup->updateFunc(popup);
        }
    }
}

Referenced by btl_update().

◆ btl_popup_messages_draw_world_geometry()

void btl_popup_messages_draw_world_geometry ( void )

Definition at line 305 of file popup_messages.c.

                                                  {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(popupMessages); i++) {
        PopupMessage* popup = &popupMessages[i];
        if (popup->active && popup->renderWorldFunc != NULL) {
            popup->renderWorldFunc(popup);
        }
    }
}

Referenced by btl_render_actors().

◆ func_80255FD8()

void func_80255FD8 ( void )

Definition at line 829 of file actor_rendering.c.

829 {

830}

Referenced by btl_render_actors().

◆ set_actor_glow_pal()

void set_actor_glow_pal	(	Actor *	actor,
		s32	arg1 )

Definition at line 2654 of file 190B20.c.

                                                     {
    for (ActorPart* part = actor->partsTable; part != NULL; part = part->nextPart) {
        if (!(part->flags & (ACTOR_PART_FLAG_USE_ABSOLUTE_POSITION | ACTOR_PART_FLAG_INVISIBLE))
            && (part->idleAnimations != NULL)
            && !(part->flags & ACTOR_PART_FLAG_NO_DECORATIONS)
        ) {
            set_part_glow_pal(part, glowState);
        }
    }
}

Referenced by appendGfx_npc_actor(), appendGfx_player_actor(), and btl_delete_actor().

◆ btl_set_popup_duration()

void btl_set_popup_duration ( s32 duration )

Definition at line 629 of file popup_messages.c.

                                          {
    PopupMessage* popup = bPopupMessage;
 
    if (ActionCommandTipVisible && popup != NULL) {
        popup->duration = duration;
    }
}

Referenced by action_command_free(), and update().

◆ switch_to_partner()

void switch_to_partner ( s32 arg0 )

Definition at line 906 of file partners.c.

                                      {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    if (wCurrentPartnerId != partnerID) {
        D_8010CFE0 = 1;
        NextPartnerID = partnerID;
 
        if (wCurrentPartnerId != PARTNER_NONE && partnerID != PARTNER_NONE) {
            NextPartnerCommand = PARTNER_CMD_SWITCH;
        } else if (partnerID == PARTNER_NONE) {
            NextPartnerCommand = PARTNER_CMD_PUT_AWAY;
        } else {
            NextPartnerCommand = PARTNER_CMD_TAKE_OUT;
            wSavedPartnerPosX = playerStatus->pos.x;
            wSavedPartnerPosY = playerStatus->pos.y;
            wSavedPartnerPosZ = playerStatus->pos.z;
        }
    }
}

Referenced by check_input_open_menus().

◆ get_current_partner_id()

s8 get_current_partner_id ( void )

Definition at line 1101 of file 7BB60.c.

                                {
    return gPlayerData.curPartner;
}

Referenced by collision_main_lateral(), and entity_try_partner_interaction_trigger().

◆ delete_trigger()

void delete_trigger ( Trigger * toDelete )

Definition at line 239 of file trigger.c.

                                       {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentTriggerListPtr); i++) {
        if ((*gCurrentTriggerListPtr)[i] == toDelete) {
            break;
        }
    }
 
    if (i < ARRAY_COUNT(*gCurrentTriggerListPtr)) {
        heap_free((*gCurrentTriggerListPtr)[i]);
        (*gCurrentTriggerListPtr)[i] = NULL;
    }
}

Referenced by evt_handle_unbind().

◆ kill_script_by_ID()

void kill_script_by_ID ( s32 id )

Definition at line 663 of file script_list.c.

                               {
    s32 i;
    Evt* scriptContextPtr;
 
    for (i = 0; i < MAX_SCRIPTS; i++) {
        scriptContextPtr = (*gCurrentScriptListPtr)[i];
        if (scriptContextPtr != NULL && scriptContextPtr->id == id) {
            kill_script(scriptContextPtr);
        }
    }
}

Referenced by _use_partner_ability(), bind_enemy_ai(), bind_enemy_aux(), bind_enemy_interact(), btl_cam_use_preset_impl(), btl_delete_actor(), btl_delete_player_actor(), btl_state_update_celebration(), dispatch_event_actor(), dispatch_event_partner(), dispatch_event_partner_continue_turn(), dispatch_event_player(), dispatch_event_player_continue_turn(), evt_handle_kill(), func_80048E34(), kill_enemy(), partner_handle_after_battle(), partner_handle_before_battle(), partner_kill_ability_script(), start_rumble_type(), and update_encounters_pre_battle().

◆ set_script_priority()

void set_script_priority	(	Evt *	script,
		s32	priority )

Definition at line 711 of file script_list.c.

                                                    {
    script->priority = priority;
}

Referenced by evt_handle_set_priority().

◆ set_script_group()

void set_script_group	(	Evt *	script,
		s32	groupFlags )

Definition at line 727 of file script_list.c.

                                                   {
    script->groupFlags = groupFlags;
}

Referenced by evt_handle_set_group().

◆ suspend_group_others()

void suspend_group_others	(	Evt *	script,
		s32	groupFlags )

Definition at line 870 of file script_list.c.

                                                       {
    s32 i;
    Evt* scriptContextPtr;
 
    for (i = 0; i < MAX_SCRIPTS; i++) {
        scriptContextPtr = (*gCurrentScriptListPtr)[i];
        if (scriptContextPtr != NULL && scriptContextPtr != script) {
            suspend_group_script(scriptContextPtr, groupFlags);
        }
    }
}

Referenced by evt_handle_suspend_others().

◆ resume_group_others()

void resume_group_others	(	Evt *	script,
		s32	groupFlags )

Definition at line 882 of file script_list.c.

                                                      {
    s32 i;
    Evt* scriptContextPtr;
 
    for (i = 0; i < MAX_SCRIPTS; i++) {
        scriptContextPtr = (*gCurrentScriptListPtr)[i];
        if (scriptContextPtr != NULL && scriptContextPtr != script) {
            resume_group_script(scriptContextPtr, groupFlags);
        }
    }
}

Referenced by evt_handle_resume_others().

◆ suspend_all_script()

s32 suspend_all_script ( s32 id )

Definition at line 798 of file script_list.c.

                               {
    s32 i;
 
    for (i = 0; i < MAX_SCRIPTS; i++) {
        Evt* scriptContextPtr = (*gCurrentScriptListPtr)[i];
 
        if (scriptContextPtr != NULL && scriptContextPtr->id == id) {
            suspend_group_script(scriptContextPtr, EVT_GROUP_NOT_BATTLE);
        }
    }
}

Referenced by evt_handle_suspend(), partner_suspend_ability_script(), start_battle(), update_encounters_neutral(), and update_encounters_pre_battle().

◆ resume_all_script()

s32 resume_all_script ( s32 id )

Definition at line 810 of file script_list.c.

                              {
    s32 i;
    Evt* scriptContextPtr;
 
    for (i = 0; i < MAX_SCRIPTS; i++) {
        scriptContextPtr = (*gCurrentScriptListPtr)[i];
        if (scriptContextPtr != NULL && scriptContextPtr->id == id) {
            resume_group_script(scriptContextPtr, EVT_GROUP_NOT_BATTLE);
        }
    }
}

Referenced by evt_handle_resume(), partner_resume_ability_script(), update_encounters_conversation(), and update_encounters_post_battle().

◆ create_shadow_type()

s32 create_shadow_type	(	s32	type,
		f32	x,
		f32	y,
		f32	z )

Definition at line 1528 of file entity.c.

                                                      {
    s32 isFixedSize = FALSE;
    ShadowBlueprint* bp = &CircularShadowA;
    s32 shadowIndex;
 
    switch (type) {
        case SHADOW_FIXED_CIRCLE:
            isFixedSize = TRUE;
        case SHADOW_VARYING_CIRCLE:
            bp = &CircularShadowA;
            break;
        case SHADOW_FIXED_SQUARE:
            isFixedSize = TRUE;
        case SHADOW_VARYING_SQUARE:
            bp = &SquareShadow;
            break;
        case SHADOW_FIXED_ALT_CIRCLE:
            isFixedSize = TRUE;
        case SHADOW_VARYING_ALT_CIRCLE:
            bp = &CircularShadowB;
            break;
    }
 
    shadowIndex = create_shadow_from_data(bp, x, y, z);
 
    if (isFixedSize) {
        get_shadow_by_index(shadowIndex)->flags |= ENTITY_FLAG_FIXED_SHADOW_SIZE;
    }
 
    return shadowIndex;
}

Referenced by create_actor(), create_entity_shadow(), create_npc_impl(), create_part_shadow(), create_part_shadow_by_ref(), load_partner_actor(), load_player_actor(), make_item_entity(), make_item_entity_at_player(), and player_reset_data().

◆ is_point_outside_territory()

b32 is_point_outside_territory	(	s32	shape,
		f32	pointX,
		f32	pointY,
		f32	centerX,
		f32	centerY,
		f32	sizeX,
		f32	sizeZ )

Definition at line 412 of file 23680.c.

                                                                                                                  {
    f32 dist1;
    f32 dist2;
 
    switch (shape) {
        case SHAPE_CYLINDER:
            dist1 = dist2D(centerX, centerZ, pointX, pointZ);
            return (sizeX < dist1);
        case SHAPE_RECT:
            dist1 = dist2D(centerX, 0, pointX, 0);
            dist2 = dist2D(0, centerZ, 0, pointZ);
            return ((sizeX < dist1) || (sizeZ < dist2));
        default:
            return FALSE;
    }
}

Referenced by basic_ai_check_player_dist(), basic_ai_wander(), CleftAI_Tackle(), FlyingAI_Wander(), FlyingAI_WanderInit(), FlyingMagikoopaAI_15(), HoppingAI_HopInit(), LakituAI_Wander(), and PiranhaPlantAI_10().

◆ npc_raycast_down_around()

b32 npc_raycast_down_around	(	s32	ignoreFlags,
		f32 *	posX,
		f32 *	posY,
		f32 *	posZ,
		f32 *	hitDepth,
		f32	yaw,
		f32	radius )

Definition at line 76 of file npc_collision.c.

                                                                                                                  {
    f32 startX;
    f32 startY;
    f32 startZ;
    f32 depth;
    f32 x;
    f32 y;
    f32 z;
    f32 originalDepth;
    f32 hitYBehindLeft;
    s32 hasCollision;
    f32 cosTheta;
    s32 colliderID;
    f32 deltaX,deltaZ;
    f32 theta, sinTheta, minDepth, hitYAhead, hitYBehindRight;
 
    hasCollision = FALSE;
    x = *posX;
    y = *posY;
    z = *posZ;
    NpcHitQueryAheadY = *posY;
    NpcHitQueryBehindRightY = *posY;
    NpcHitQueryBehindLeftY = *posY;
    radius /= 2.5;
    hitYBehindLeft = hitYBehindRight = hitYAhead = -32767.0f;
    minDepth = fabsf(*hitDepth);
 
    theta = DEG_TO_RAD(clamp_angle(yaw + 0.0f));
    sinTheta = sin_rad(theta);
    cosTheta = cos_rad(theta);
    deltaX = radius * sinTheta;
    deltaZ = -radius * cosTheta;
 
    startX = x + deltaX;
    startY = y;
    startZ = z + deltaZ;
    originalDepth = depth = minDepth;
 
    colliderID = npc_raycast_down(ignoreFlags, &startX, &startY, &startZ, &depth);
    if (colliderID > NO_COLLIDER) {
        if (depth <= minDepth) {
            hitYAhead = startY;
            NpcHitQueryColliderID = colliderID;
            NpcHitQueryAheadCollider = colliderID;
            NpcHitQueryAheadY = hitYAhead;
            minDepth = depth;
            hasCollision = TRUE;
        }
    }
 
    theta = DEG_TO_RAD(clamp_angle(yaw + 120.0f));
    sinTheta = sin_rad(theta);
    cosTheta = cos_rad(theta);
    deltaX = radius * sinTheta;
    deltaZ = -radius * cosTheta;
 
    startX = x + deltaX;
    startY = y;
    startZ = z + deltaZ;
    depth = originalDepth;
 
    colliderID = npc_raycast_down(ignoreFlags, &startX, &startY, &startZ, &depth);
    if (colliderID > NO_COLLIDER) {
        if (depth <= minDepth) {
            hitYBehindRight = startY;
            NpcHitQueryColliderID = colliderID;
            NpcHitQueryBehindCollider = colliderID;
            NpcHitQueryBehindRightY = hitYBehindRight;
            minDepth = depth;
            hasCollision = TRUE;
        }
    }
 
    theta = DEG_TO_RAD(clamp_angle(yaw - 120.0f));
    sinTheta = sin_rad(theta);
    cosTheta = cos_rad(theta);
    deltaX = radius * sinTheta;
    deltaZ = -radius * cosTheta;
 
    startX = x + deltaX;
    startY = y;
    startZ = z + deltaZ;
    depth = originalDepth;
 
    colliderID = npc_raycast_down(ignoreFlags, &startX, &startY, &startZ, &depth);
    if (colliderID > NO_COLLIDER) {
        if (depth <= minDepth) {
            hitYBehindLeft = startY;
            NpcHitQueryColliderID = colliderID;
            NpcHitQueryBehindCollider = colliderID;
            NpcHitQueryBehindLeftY = hitYBehindLeft;
            minDepth = depth;
            hasCollision = TRUE;
        }
    }
 
    if (hasCollision) {
        *posY = MAX(hitYBehindRight, hitYAhead);
        if (*posY < hitYBehindLeft) {
            *posY = hitYBehindLeft;
        }
        *hitDepth = minDepth;
        return TRUE;
    }
 
    *posY = startY;
    return FALSE;
}

Referenced by func_80262130(), npc_try_apply_gravity(), npc_try_snap_to_ground(), partner_flying_follow_player(), partner_flying_update_motion(), partner_get_out(), partner_move_to_goal(), partner_walking_follow_player(), test_for_water_level(), update_item_entity_collectable(), and update_riding_physics().

◆ npc_raycast_down_sides()

b32 npc_raycast_down_sides	(	s32	ignoreFlags,
		f32 *	posX,
		f32 *	posY,
		f32 *	posZ,
		f32 *	hitDepth )

Definition at line 186 of file npc_collision.c.

                                                                                            {
    f32 startX;
    f32 startY;
    f32 startZ;
    f32 depth;
    f32 x;
    f32 y;
    f32 z;
    f32 originalDepth;
    f32 hitYUnused;
    s32 hasCollision;
    f32 cosTheta;
    s32 colliderID;
    f32 deltaX,deltaZ;
    f32 yaw;
    f32 theta, sinTheta, minDepth, hitYAhead, hitYBehind, radius;
 
    hasCollision = FALSE;
 
    x = *posX;
    y = *posY;
    z = *posZ;
 
    NpcHitQueryAheadY = y;
    NpcHitQueryBehindRightY = *posY;
    NpcHitQueryBehindLeftY = *posY;
 
    hitYUnused = hitYBehind = hitYAhead = -32767.0f;
    yaw = 0.0f;
 
    minDepth = fabsf(*hitDepth);
    theta = DEG_TO_RAD(clamp_angle(yaw));
    sinTheta = sin_rad(theta);
    cosTheta = cos_rad(theta);
 
    radius = 10.0f;
 
    deltaX = radius * sinTheta;
    deltaZ = -radius * cosTheta;
 
    startX = x + deltaX;
    startY = y;
    startZ = z + deltaZ;
    originalDepth = depth = minDepth;
 
    colliderID = npc_raycast_down(ignoreFlags, &startX, &startY, &startZ, &depth);
    if (colliderID > NO_COLLIDER) {
        if (depth <= minDepth) {
            hitYAhead = startY;
            NpcHitQueryColliderID = colliderID;
            NpcHitQueryAheadCollider = colliderID;
            NpcHitQueryAheadY = hitYAhead;
            minDepth = depth;
            hasCollision = TRUE;
        }
    }
 
    theta = DEG_TO_RAD(clamp_angle(yaw + 180.0f));
    sinTheta = sin_rad(theta);
    cosTheta = cos_rad(theta);
    deltaX = radius * sinTheta;
    deltaZ = -radius * cosTheta;
 
    startX = x + deltaX;
    startY = y;
    startZ = z + deltaZ;
    depth = originalDepth;
 
    colliderID = npc_raycast_down(ignoreFlags, &startX, &startY, &startZ, &depth);
    if (colliderID > NO_COLLIDER) {
        if (depth <= minDepth) {
            hitYBehind = startY;
            NpcHitQueryColliderID = colliderID;
            NpcHitQueryBehindCollider = colliderID;
            NpcHitQueryBehindRightY = hitYBehind;
            minDepth = depth;
            hasCollision = TRUE;
        }
    }
 
    if (hasCollision) {
        *posY = MAX(hitYBehind, hitYAhead);
        if (*posY < hitYUnused) {
            *posY = hitYUnused;
        }
        *hitDepth = minDepth;
        return TRUE;
    }
 
    return FALSE;
}

◆ npc_raycast_up()

b32 npc_raycast_up	(	s32	ignoreFlags,
		f32 *	startX,
		f32 *	startY,
		f32 *	startZ,
		f32 *	hitDepth )

Definition at line 278 of file npc_collision.c.

                                                                                          {
    f32 cHitX;
    f32 cHitY;
    f32 cHitZ;
    f32 cHitDepth;
    f32 cHitNx;
    f32 cHitNy;
    f32 cHitNz;
    f32 eHitX;
    f32 eHitY;
    f32 eHitZ;
    f32 eHitDepth;
    f32 eHitNx;
    f32 eHitNy;
    f32 eHitNz;
    s32 entityID;
    s32 colliderID;
    f32 sx, sy, sz;
    s32 ret;
 
    eHitDepth = cHitDepth = *hitDepth;
    sx = *startX;
    sy = *startY;
    sz = *startZ;
    ret = test_ray_colliders(ignoreFlags, sx, sy, sz, 0.0f, 1.0f, 0.0f, &cHitX, &cHitY, &cHitZ, &cHitDepth, &cHitNx, &cHitNy, &cHitNz);
    colliderID = ret;
    if (!(ignoreFlags & COLLISION_IGNORE_ENTITIES))  {
        entityID = test_ray_entities(sx, sy, sz, 0.0f, 1.0f, 0.0f, &eHitX, &eHitY, &eHitZ, &eHitDepth, &eHitNx, &eHitNy, &eHitNz);
        ret = entityID | COLLISION_WITH_ENTITY_BIT;
        if (entityID > NO_COLLIDER) {
            cHitDepth = eHitDepth;
            cHitX = eHitX;
            cHitY = eHitY;
            cHitZ = eHitZ;
            cHitNx = eHitNx;
            cHitNy = eHitNy;
            cHitNz = eHitNz;
        } else {
            ret = colliderID;
        }
    }
 
    if (ret <= NO_COLLIDER) {
        return FALSE;
    } else {
        *hitDepth = cHitDepth;
        *startX = cHitX;
        *startY = cHitY;
        *startZ = cHitZ;
        NpcHitQueryColliderID = ret;
        return TRUE;
    }
}

Referenced by partner_flying_update_motion(), and update_item_entity_collectable().

◆ npc_raycast_up_corners()

HitID npc_raycast_up_corners	(	s32	ignoreFlags,
		f32 *	posX,
		f32 *	posY,
		f32 *	posZ,
		f32 *	hitDepth,
		f32	yaw,
		f32	radius )

Definition at line 376 of file npc_collision.c.

                                                                                                                   {
    f32 startX;
    f32 startY;
    f32 startZ;
    f32 depth;
    f32 theta;
    f32 deltaZ;
    f32 deltaX;
    f32 x,y,z;
    s32 ret;
    s32 hitID;
 
    theta = DEG_TO_RAD(yaw);
    deltaX = radius * sin_rad(theta);
    deltaZ = -radius * cos_rad(theta);
 
    x = *posX;
    y = *posY;
    z = *posZ;
 
    depth = *hitDepth;
    startX = x + deltaX;
    startY = y;
    startZ = z + deltaZ;
 
    ret = NO_COLLIDER;
    hitID = npc_raycast_up_corner(ignoreFlags, &startX, &startY, &startZ, &depth);
 
    if (hitID <= NO_COLLIDER) {
        startX = x - deltaX;
        startY = y;
        startZ = z - deltaZ;
        hitID = npc_raycast_up_corner(ignoreFlags, &startX, &startY, &startZ, &depth);
    }
 
    if (hitID <= NO_COLLIDER) {
        startX = x + deltaZ;
        startY = y;
        startZ = z + deltaX;
        hitID = npc_raycast_up_corner(ignoreFlags, &startX, &startY, &startZ, &depth);
    }
 
    if (hitID <= NO_COLLIDER) {
        startX = x - deltaZ;
        startY = y;
        startZ = z - deltaX;
        hitID = npc_raycast_up_corner(ignoreFlags, &startX, &startY, &startZ, &depth);
    }
 
    if (hitID > NO_COLLIDER) {
        *posX = startX;
        *posY = startY;
        *posZ = startZ;
        *hitDepth = depth;
        ret = hitID;
    }
 
    if (ret <= NO_COLLIDER) {
        *posX = startX;
        *posY = startY;
        *posZ = startZ;
        *hitDepth = 0;
    }
 
    return ret;
}

Referenced by update_riding_physics().

◆ player_raycast_up_corners()

HitID player_raycast_up_corners	(	PlayerStatus *	player,
		f32 *	posX,
		f32 *	posY,
		f32 *	posZ,
		f32 *	hitDepth,
		f32	yaw )

Definition at line 255 of file 77480.c.

                                                                                                               {
    f32 startX;
    f32 startY;
    f32 startZ;
    f32 depth;
    f32 theta;
    f32 deltaZ;
    f32 deltaX;
    f32 x,y,z;
    s32 ret;
    s32 hitID;
    f32 radius;
 
    radius = player->colliderDiameter * 0.3f;
    theta = DEG_TO_RAD(yaw);
    deltaX = radius * sin_rad(theta);
    deltaZ = -radius * cos_rad(theta);
 
    x = *posX;
    y = *posY;
    z = *posZ;
 
    depth = *hitDepth;
    startX = x + deltaX;
    startY = y;
    startZ = z + deltaZ;
 
    ret = NO_COLLIDER;
    hitID = player_raycast_up_corner(&startX, &startY, &startZ, &depth);
 
    if (hitID <= NO_COLLIDER) {
        startX = x - deltaX;
        startY = y;
        startZ = z - deltaZ;
        hitID = player_raycast_up_corner(&startX, &startY, &startZ, &depth);
    }
 
    if (hitID <= NO_COLLIDER) {
        startX = x + deltaZ;
        startY = y;
        startZ = z + deltaX;
        hitID = player_raycast_up_corner(&startX, &startY, &startZ, &depth);
    }
 
    if (hitID <= NO_COLLIDER) {
        startX = x - deltaZ;
        startY = y;
        startZ = z - deltaX;
        hitID = player_raycast_up_corner(&startX, &startY, &startZ, &depth);
    }
 
    if (hitID > NO_COLLIDER) {
        *posX = startX;
        *posY = startY;
        *posZ = startZ;
        *hitDepth = depth;
        ret = hitID;
    }
 
    if (ret <= NO_COLLIDER) {
        *posX = startX;
        *posY = startY;
        *posZ = startZ;
        *hitDepth = 0;
    }
 
    return ret;
}

Referenced by collision_main_above().

◆ player_raycast_below_cam_relative()

HitID player_raycast_below_cam_relative	(	PlayerStatus *	playerStatus,
		f32 *	outX,
		f32 *	outY,
		f32 *	outZ,
		f32 *	outLength,
		f32 *	hitRx,
		f32 *	hitRz,
		f32 *	hitDirX,
		f32 *	hitDirZ )

Definition at line 193 of file 77480.c.

                                                                                          {
    f32 yaw = 0.0f;
 
    if (playerStatus->spriteFacingAngle >= 90.0f && playerStatus->spriteFacingAngle < 270.0f) {
        yaw = 180.0f;
    }
 
    return player_raycast_below(yaw - 90.0f + gCameras[gCurrentCameraID].curYaw, playerStatus->colliderDiameter,
                                outX, outY, outZ, outLength, hitRx, hitRz, hitDirX, hitDirZ);
}

Referenced by action_update_sliding(), action_update_state_23(), action_update_step_down(), can_dismount(), phys_main_collision_below(), player_check_collision_below(), test_dismount_height(), test_mounting_height_adjustment(), update_current_floor(), and update_riding_physics().

◆ npc_test_move_taller_with_slipping()

b32 npc_test_move_taller_with_slipping	(	s32	ignoreFlags,
		f32 *	x,
		f32 *	y,
		f32 *	z,
		f32	length,
		f32	yaw,
		f32	height,
		f32	radius )

Definition at line 566 of file npc_collision.c.

                                                   {
    f32 xTemp = *x;
    f32 yTemp = *y + height - 1.0f;
    f32 zTemp = *z;
    s32 ret;
 
    radius *= 0.5f;
    if (npc_test_move_with_slipping(ignoreFlags, &xTemp, &yTemp, &zTemp, fabsf(length), yaw, radius) <= NO_COLLIDER) {
        xTemp = *x;
        yTemp = *y + 10.01f;
        zTemp = *z;
        ret = npc_test_move_with_slipping(ignoreFlags, &xTemp, &yTemp, &zTemp, fabsf(length), yaw, radius) > NO_COLLIDER;
        *x = xTemp;
        *z = zTemp;
    } else {
        ret = TRUE;
        *x = xTemp;
        *z = zTemp;
    }
    return ret;
}

Referenced by apply_riding_static_collisions(), blast_affect_entities(), check_conversation_trigger(), Entity_BoardedFloor_update_fragments(), entity_BombableRock_update_fragments(), entity_shattering_idle(), entity_WoodenCrate_update_fragments(), FlyingMagikoopaAI_15(), npc_do_world_collision(), partner_flying_follow_player(), test_first_strike(), test_first_strike(), update_encounters_neutral(), update_riding_physics(), and update_riding_physics().

◆ npc_test_move_simple_with_slipping()

b32 npc_test_move_simple_with_slipping	(	s32	ignoreFlags,
		f32 *	x,
		f32 *	y,
		f32 *	z,
		f32	length,
		f32	yaw,
		f32	height,
		f32	radius )

Definition at line 589 of file npc_collision.c.

                                                   {
    f32 tempX = *x;
    f32 tempY = *y + 10.01f;
    f32 tempZ = *z;
    s32 hitID = npc_test_move_with_slipping(ignoreFlags, &tempX, &tempY, &tempZ, fabsf(length), yaw, radius * 0.5f);
 
    *x = tempX;
    *z = tempZ;
 
    return hitID > NO_COLLIDER;
}

Referenced by ai_check_fwd_collisions(), apply_riding_static_collisions(), basic_ai_chase(), basic_ai_check_player_dist(), basic_ai_loiter(), basic_ai_wander(), CleftAI_Tackle(), HoppingAI_Chase(), HoppingAI_Hop(), HoppingAI_HopInit(), npc_do_world_collision(), PiranhaPlantAI_10(), UnkNpcAIFunc12(), and update_item_entity_collectable().

◆ npc_test_move_complex_with_slipping()

s32 npc_test_move_complex_with_slipping	(	s32	ignoreFlags,
		f32 *	x,
		f32 *	y,
		f32 *	z,
		f32	length,
		f32	yaw,
		f32	height,
		f32	radius )

Definition at line 618 of file npc_collision.c.

                                                    {
    f32 startX;
    f32 startY;
    f32 startZ;
    s32 ret = 0;
    s32 hitID;
 
    radius *= 0.5f;
    startX = *x;
    startY = *y + height - 1.0f;
    startZ = *z;
    if (npc_test_move_with_slipping(ignoreFlags, &startX, &startY, &startZ, fabsf(length), yaw, radius) > NO_COLLIDER) {
        *x = startX;
        *z = startZ;
        ret = 4;
    }
 
    startX = *x;
    startY = *y + 20.0f;
    startZ = *z;
    if (npc_test_move_with_slipping(ignoreFlags, &startX, &startY, &startZ, fabsf(length), yaw, radius) > NO_COLLIDER) {
        *x = startX;
        *z = startZ;
        ret = 3;
    }
 
    startX = *x;
    startY = *y + 15.01f;
    startZ = *z;
    if (npc_test_move_with_slipping(ignoreFlags, &startX, &startY, &startZ, fabsf(length), yaw, radius) > NO_COLLIDER) {
        *x = startX;
        *z = startZ;
        ret = 2;
    }
 
    startX = *x;
    startY = *y + 10.01f;
    startZ = *z;
    hitID = npc_test_move_with_slipping(ignoreFlags, &startX, &startY, &startZ, fabsf(length), yaw, radius);
    *x = startX;
    *z = startZ;
    if (hitID > NO_COLLIDER) {
        ret = 1;
    }
 
    return ret;
}

Referenced by apply_riding_static_collisions(), npc_do_world_collision(), update_item_entity_collectable(), and update_riding_physics().

◆ partner_get_enter_map_script()

EvtScript * partner_get_enter_map_script ( void )

Definition at line 1058 of file partners.c.

                                              {
    WorldPartner* partner = wPartner;
 
    if (partner == NULL) {
        return NULL;
    }
    return partner->onEnterMap;
}

◆ partner_handle_before_battle()

void partner_handle_before_battle ( void )

Definition at line 1067 of file partners.c.

                                        {
    if (wCurrentPartnerId != PARTNER_NONE) {
        s32* scriptID = &wPartnerCurrentScriptID;
 
        if (does_script_exist(*scriptID)) {
            kill_script_by_ID(*scriptID);
        }
 
        if (wPartner->preBattle != NULL) {
            wPartner->preBattle(wPartnerNpc);
        }
    }
}

Referenced by update_encounters_pre_battle().

◆ partner_walking_update_player_tracking()

void partner_walking_update_player_tracking ( Npc * partner )

Definition at line 1175 of file partners.c.

                                                          {
    PlayerStatus* playerStatus = &gPlayerStatus;
    s32 isPlayerJumping;
    PlayerPathElement* currentSnapshot;
 
    if (playerStatus->flags & (PS_FLAG_FALLING | PS_FLAG_JUMPING)) {
        isPlayerJumping = (playerStatus->actionState == ACTION_STATE_LAND || playerStatus->actionState == ACTION_STATE_STEP_DOWN) ^ 1;
    } else {
        isPlayerJumping = FALSE;
    }
    currentSnapshot = &gPlayerMoveHistory[gPlayerMoveHistoryIndex];
    if ((!currentSnapshot->isJumping || !isPlayerJumping) &&
        ((currentSnapshot->pos.x != playerStatus->pos.x) || (currentSnapshot->pos.y != playerStatus->pos.y)
        || (currentSnapshot->pos.z != playerStatus->pos.z))) {
        if (D_8010CFBC != gPlayerMoveHistoryIndex + 1) {
            if (++gPlayerMoveHistoryIndex >= ARRAY_COUNT(gPlayerMoveHistory)) {
                gPlayerMoveHistoryIndex = 0;
            }
            currentSnapshot = &gPlayerMoveHistory[gPlayerMoveHistoryIndex];
            currentSnapshot->pos.x = playerStatus->pos.x;
            currentSnapshot->pos.y = playerStatus->pos.y;
            currentSnapshot->pos.z = playerStatus->pos.z;
            currentSnapshot->isJumping = isPlayerJumping;
        }
    }
}

◆ partner_walking_update_motion()

void partner_walking_update_motion ( Npc * partner )

Definition at line 1202 of file partners.c.

                                                 {
    PlayerStatus* playerStatus = &gPlayerStatus;
    PartnerStatus* partnerStatus = &gPartnerStatus;
 
    if (!gGameStatusPtr->multiplayerEnabled || playerStatus->flags & (PS_FLAG_INPUT_DISABLED | PS_FLAG_NO_STATIC_COLLISION)
        || partnerStatus->inputDisabledCount != 0 || partnerStatus->partnerAction_unk_2) {
        if (!(playerStatus->animFlags & PA_FLAG_OPENED_HIDDEN_PANEL)) {
            partner_walking_follow_player(partner);
        }
        if (partnerStatus->pressedButtons & (BUTTON_Z | BUTTON_B | BUTTON_C_LEFT | BUTTON_C_DOWN)) {
            partnerStatus->partnerAction_unk_2 = FALSE;
        }
    }
 
    if (wPartnerFollowState != 50 && fabsf(partner->pos.y - playerStatus->pos.y) > 1000.0f) {
        partner->pos.x = playerStatus->pos.x;
        partner->pos.y = playerStatus->pos.y;
        partner->pos.z = playerStatus->pos.z;
        partner->jumpVel = 0.0f;
        partner->jumpScale = 0.0f;
        partner->flags = partner->flags & ~PA_FLAG_OPENED_HIDDEN_PANEL;
    }
 
    partner_do_player_collision(partner);
    wSavedPartnerPosX = partner->pos.x;
    wSavedPartnerPosY = partner->pos.y;
    wSavedPartnerPosZ = partner->pos.z;
}

◆ enable_partner_ai()

void enable_partner_ai ( void )

Definition at line 2390 of file partners.c.

                             {
    wPartnerFollowState = 0;
    partner_clear_player_tracking(wPartnerNpc);
 
    if (!wPartner->isFlying) {
        partner_walking_enable(wPartnerNpc, FALSE);
    } else {
        partner_flying_enable(wPartnerNpc, FALSE);
    }
}

Referenced by action_update_use_spinning_flower(), entity_CymbalPlant_idle(), and func_802BC32C_E2EC5C().

◆ partner_walking_enable()

void partner_walking_enable	(	Npc *	partner,
		s32	val )

Definition at line 1133 of file partners.c.

                                                   {
    PlayerStatus* playerStatus = &gPlayerStatus;
    PlayerPathElement* it = gPlayerMoveHistory;
    s32 i;
 
    partner->pos.x = wSavedPartnerPosX;
    partner->pos.y = wSavedPartnerPosY;
    partner->pos.z = wSavedPartnerPosZ;
 
    for (i = 0; i < ARRAY_COUNT(gPlayerMoveHistory); i++, it++) {
        it->pos.x = playerStatus->pos.x;
        it->pos.y = playerStatus->pos.y;
        it->pos.z = playerStatus->pos.z;
        it->isJumping = FALSE;
    }
 
    gPlayerMoveHistoryIndex = 0;
    D_8010CFBC = 0;
    D_8010CFCA = val ? 2 : 0;
    wPartnerFollowState = 0;
 
    if (D_8010CFC4 == 1 || D_8010CFC4 == 3) {
        D_8010CFC4 = 0;
        D_8010CFCA = 0;
        wPartnerFollowState = 0;
    } else if (D_8010CFC4 == 2) {
        D_8010CFCA = 0;
        wPartnerFollowState = 50;
    }
 
    D_8010CFCE = 0;
    D_8010CFCC = 0;
    wPartnerMoveTime = 16;
    wPartnerTetherDistance = 40.0f;
    partner->curAnim = gPartnerAnimations[wCurrentPartnerId].idle;
    func_800EA5B8(partner);
    partner->collisionChannel = COLLIDER_FLAG_IGNORE_PLAYER;
    partner->jumpVel = 0.0f;
    partner->flags |= NPC_FLAG_TOUCHES_GROUND | NPC_FLAG_GRAVITY | NPC_FLAG_IGNORE_PLAYER_COLLISION;
    partner->jumpScale = 1.8f;
}

Referenced by enable_partner_ai().

◆ partner_flying_enable()

void partner_flying_enable	(	Npc *	partner,
		s32	val )

Definition at line 1706 of file partners.c.

                                                  {
    PlayerStatus* playerStatus = &gPlayerStatus;
    PlayerPathElement* it = gPlayerMoveHistory;
    s32 i;
 
    partner->pos.x = wSavedPartnerPosX;
    partner->pos.y = wSavedPartnerPosY;
    partner->pos.z = wSavedPartnerPosZ;
 
    for (i = 0; i < ARRAY_COUNT(gPlayerMoveHistory); i++, it++) {
        it->pos.x = wSavedPartnerPosX;
        it->pos.y = wSavedPartnerPosY;
        it->pos.z = wSavedPartnerPosZ;
        it->isJumping = FALSE;
    }
 
    gPlayerMoveHistoryIndex = 0;
    D_8010CFBC = 0;
 
    if (!val) {
        wPartnerFollowState = 0;
        D_8010CFCA = 0;
    } else if (D_8010CFC4 == 0) {
        wPartnerFollowState = 15;
        D_8010CFCA = 2;
    } else if (D_8010CFC4 == 1 || D_8010CFC4 == 3) {
        D_8010CFC4 = 0;
        wPartnerFollowState = 0;
        D_8010CFCA = 0;
    } else if (D_8010CFC4 == 2) {
        wPartnerFollowState = 50;
        D_8010CFCA = 0;
    }
 
    D_8010CFCE = 0;
    D_8010CFCC = 0;
    wPartnerMoveTime = 16;
    wPartnerTetherDistance = 40.0f;
    partner->curAnim = gPartnerAnimations[wCurrentPartnerId].idle;
    func_800EA5B8(partner);
    partner->collisionChannel = COLLIDER_FLAG_IGNORE_PLAYER;
    partner->flags |= NPC_FLAG_IGNORE_PLAYER_COLLISION;
    partner->flags &= ~NPC_FLAG_GRAVITY;
}

Referenced by enable_partner_ai().

◆ partner_flying_update_player_tracking()

void partner_flying_update_player_tracking ( Npc * partner )

Definition at line 1751 of file partners.c.

                                                         {
    PlayerStatus* playerStatus = &gPlayerStatus;
    PlayerPathElement* currentSnapshot;
    f32 effectiveY;
    s32 isPlayerJumping = FALSE;
 
    effectiveY = playerStatus->pos.y;
    if ((playerStatus->actionState == ACTION_STATE_HIT_LAVA) || (playerStatus->actionState == ACTION_STATE_HIT_FIRE)) {
        effectiveY = playerStatus->lastGoodPos.y + partner->collisionHeight + 5;
    }
    currentSnapshot = &gPlayerMoveHistory[gPlayerMoveHistoryIndex];
    if ((!currentSnapshot->isJumping || !isPlayerJumping) && (currentSnapshot->pos.x != playerStatus->pos.x || currentSnapshot->pos.y != effectiveY
        || currentSnapshot->pos.z != playerStatus->pos.z)) {
        if (D_8010CFBC != gPlayerMoveHistoryIndex + 1) {
            if (++gPlayerMoveHistoryIndex >= ARRAY_COUNT(gPlayerMoveHistory)) {
                gPlayerMoveHistoryIndex = 0;
            }
            currentSnapshot = &gPlayerMoveHistory[gPlayerMoveHistoryIndex];
            currentSnapshot->pos.x = playerStatus->pos.x;
            currentSnapshot->pos.y = effectiveY;
            currentSnapshot->pos.z = playerStatus->pos.z;
            currentSnapshot->isJumping = isPlayerJumping;
        }
    }
}

◆ partner_is_flying()

s32 partner_is_flying ( void )

Definition at line 572 of file partners.c.

                            {
    return !wPartner->isFlying;
}

◆ partner_flying_update_motion()

void partner_flying_update_motion ( Npc * partner )

Definition at line 1777 of file partners.c.

                                                {
    PlayerStatus* playerStatus = &gPlayerStatus;
    PartnerStatus* partnerStatus = &gPartnerStatus;
    f32 x, y, z, hitDepth;
    f32 var_f0;
    f32 var_f2;
 
    if (!gGameStatusPtr->multiplayerEnabled ||
        (playerStatus->flags & (PS_FLAG_INPUT_DISABLED | PS_FLAG_NO_STATIC_COLLISION)) ||
        partnerStatus->inputDisabledCount ||
        partnerStatus->partnerAction_unk_2)
    {
        if (!(playerStatus->animFlags & PA_FLAG_OPENED_HIDDEN_PANEL) || D_800F8020 == 0) {
            partner_flying_follow_player(partner);
        }
        if (partnerStatus->pressedButtons & (BUTTON_B | BUTTON_Z | BUTTON_C_DOWN | BUTTON_C_LEFT)) {
            partnerStatus->partnerAction_unk_2 = FALSE;
        }
    }
    if (wPartnerFollowState != 50 && fabsf(partner->pos.y - playerStatus->pos.y) > 1000.0f) {
        partner->pos.x = playerStatus->pos.x;
        partner->pos.y = playerStatus->pos.y;
        partner->pos.z = playerStatus->pos.z;
        partner->jumpVel = 0.0f;
        partner->jumpScale = 0.0f;
        partner->flags &= ~NPC_FLAG_JUMPING;
    }
 
    D_800F8020 = 0;
    x = partner->pos.x;
    y = partner->pos.y + (partner->collisionHeight * 0.5f);
    z = partner->pos.z;
 
    hitDepth = partner->collisionHeight * 0.5f;
    if (npc_raycast_up(0, &x, &y, &z, &hitDepth)) {
        D_800F8020 = 1;
        wSavedPartnerPosX = partner->pos.x;
        wSavedPartnerPosY = partner->pos.y;
        wSavedPartnerPosZ = partner->pos.z;
    } else {
        partner_do_player_collision(partner);
        if (wPartnerFollowState != 50) {
            x = partner->pos.x;
            y = partner->pos.y;
            z = partner->pos.z;
            hitDepth = 1000.0f;
            if (npc_raycast_down_around(COLLIDER_FLAG_IGNORE_PLAYER, &x, &y, &z, &hitDepth, partner->yaw, partner->collisionDiameter) == 0) {
                y = playerStatus->pos.y;
            }
 
            if (partner->pos.y <= y + partner->collisionHeight + 2.0f) {
                if (playerStatus->curSpeed != 0.0f) {
                    D_800F84F8 = ((y + (partner->collisionHeight / 2) + 2.0f) - partner->pos.y) * 0.125f;
                } else {
                    if (y < playerStatus->pos.y) {
                        var_f0 = playerStatus->pos.y + 10.0f - partner->pos.y;
                    } else {
                        var_f0 = y + 10.0f - partner->pos.y;
                    }
                    var_f2 = 0.25f;
                    D_800F84F8 = var_f0 * var_f2;
                }
            } else {
                if (playerStatus->pos.y + playerStatus->colliderHeight < y) {
                    D_800F84F8 = (y + partner->collisionHeight - partner->pos.y) * 0.125f;
                    if (partner->pos.y + D_800F84F8 <= y + partner->collisionHeight) {
                        D_800F84F8 = (y + partner->collisionHeight - partner->pos.y) * 0.25f;
                    }
                } else {
                    var_f0 = (playerStatus->pos.y + playerStatus->colliderHeight + 5.0f) - partner->pos.y;
                    var_f2 = 0.0625f;
                    D_800F84F8 = var_f0 * var_f2;
                }
            }
            partner->pos.y += D_800F84F8;
        }
        wSavedPartnerPosX = partner->pos.x;
        wSavedPartnerPosY = partner->pos.y;
        wSavedPartnerPosZ = partner->pos.z;
    }
}

◆ partner_clear_player_tracking()

void partner_clear_player_tracking ( Npc * partner )

Definition at line 2436 of file partners.c.

                                                 {
    PlayerPathElement* it = gPlayerMoveHistory;
    s32 i;
 
    wSavedPartnerPosX = partner->pos.x;
    wSavedPartnerPosY = partner->pos.y;
    wSavedPartnerPosZ = partner->pos.z;
 
    for (i = 0; i < ARRAY_COUNT(gPlayerMoveHistory); i++, it++) {
        it->pos.x = wSavedPartnerPosX;
        it->pos.y = wSavedPartnerPosY;
        it->pos.z = wSavedPartnerPosZ;
        it->isJumping = FALSE;
    }
}

Referenced by enable_partner_ai(), end_outta_sight_cleanup(), partner_flying_follow_player(), partner_get_out(), partner_walking_follow_player(), post_battle(), post_battle(), pre_battle(), pre_battle(), pre_battle(), pre_battle(), pre_battle(), pre_battle(), pre_battle(), pre_battle(), try_cancel_tweester(), try_cancel_tweester(), try_cancel_tweester(), try_cancel_tweester(), try_cancel_tweester(), try_cancel_tweester(), try_cancel_tweester(), try_cancel_tweester(), and try_cancel_tweester().

◆ partner_set_tether_distance()

void partner_set_tether_distance ( f32 dist )

Definition at line 2401 of file partners.c.

                                           {
    wPartnerTetherDistance = dist;
}

◆ btl_delete_player_actor()

void btl_delete_player_actor ( Actor * player )

Definition at line 1175 of file 16C8E0.c.

                                            {
    ActorPart* partsTable;
    ActorPartMovement* movement;
    DecorationTable* decorations;
    s32 i;
 
    for (i = 0; i < 2; i++) {
        remove_actor_decoration(player, i);
    }
 
    if (player->idleScript != NULL) {
        kill_script_by_ID(player->idleScriptID);
    }
    if (player->handleEventScript != NULL) {
        kill_script_by_ID(player->handleEventScriptID);
    }
    if (player->takeTurnScript != NULL) {
        kill_script_by_ID(player->takeTurnScriptID);
    }
 
    partsTable = player->partsTable;
    decorations = partsTable->decorationTable;
    movement = partsTable->movement;
 
    delete_shadow(player->shadow.id);
    remove_all_status_icons(player->hudElementDataIndex);
    remove_effect(player->disableEffect);
 
    if (player->attackResultEffect != NULL) {
        player->attackResultEffect->data.attackResultText->isVisible = FALSE;
    }
 
    heap_free(movement);
    heap_free(decorations);
    heap_free(partsTable);
    heap_free(player);
}

Referenced by btl_state_update_end_battle(), and btl_state_update_end_demo_battle().

◆ cancel_message()

s32 cancel_message ( MessagePrintState * msgPrintState )

Definition at line 1507 of file msg.c.

                                                     {
    if (!(msgPrintState->stateFlags & MSG_STATE_FLAG_2)) {
        return FALSE;
    }
 
    msgPrintState->stateFlags |= MSG_STATE_FLAG_1;
    return TRUE;
}

Referenced by cancel_current_message().

◆ set_message_images()

void set_message_images ( MessageImageData * images )

Definition at line 1516 of file msg.c.

                                                  {
    *gMsgVarImages = images;
}

◆ kill_all_scripts()

void kill_all_scripts ( void )

Definition at line 675 of file script_list.c.

                            {
    s32 i;
    Evt* scriptContextPtr;
 
    for (i = 0; i < MAX_SCRIPTS; i++) {
        scriptContextPtr = (*gCurrentScriptListPtr)[i];
        if (scriptContextPtr != NULL) {
            kill_script(scriptContextPtr);
        }
    }
}

Referenced by btl_state_update_end_battle(), and btl_state_update_end_demo_battle().

◆ does_script_exist()

s32 does_script_exist ( s32 id )

Definition at line 687 of file script_list.c.

                              {
    s32 i;
    Evt* scriptContextPtr;
 
    for (i = 0; i < MAX_SCRIPTS; i++) {
        scriptContextPtr = (*gCurrentScriptListPtr)[i];
        if (scriptContextPtr != NULL && scriptContextPtr->id == id) {
            return TRUE;
        }
    }
    return FALSE;
}

◆ does_script_exist_by_ref()

s32 does_script_exist_by_ref ( Evt * script )

Definition at line 700 of file script_list.c.

                                          {
    s32 i;
 
    for (i = 0; i < MAX_SCRIPTS; i++) {
        if (script == (*gCurrentScriptListPtr)[i]) {
            return TRUE;
        }
    }
    return FALSE;
}

◆ start_script()

Evt * start_script	(	EvtScript *	source,
		s32	priority,
		s32	initialState )

Definition at line 217 of file script_list.c.

                                                              {
    Evt* newScript;
    s32 scriptListCount;
    s32 curScriptIndex;
    s32 i;
 
    for (i = 0; i < MAX_SCRIPTS; i++) {
        if ((*gCurrentScriptListPtr)[i] == NULL) {
            break;
        }
    }
 
    ASSERT(i < MAX_SCRIPTS);
    curScriptIndex = i;
 
    (*gCurrentScriptListPtr)[curScriptIndex] = newScript = heap_malloc(sizeof(*newScript));
    gNumScripts++;
    ASSERT(newScript != NULL);
 
    newScript->stateFlags = flags | EVT_FLAG_ACTIVE;
    newScript->curOpcode = EVT_OP_INTERNAL_FETCH;
    newScript->priority = priority;
    newScript->id = UniqueScriptCounter++;
    newScript->ptrNextLine = (Bytecode*)source;
    newScript->ptrFirstLine = (Bytecode*)source;
    newScript->ptrCurLine = (Bytecode*)source;
    newScript->userData = NULL;
    newScript->blockingParent = NULL;
    newScript->childScript = NULL;
    newScript->parentScript = NULL;
    newScript->owner1.actorID = -1;
    newScript->owner2.npcID = -1;
    newScript->loopDepth = -1;
    newScript->switchDepth = -1;
    newScript->groupFlags = EVT_GROUP_NOT_BATTLE;
    newScript->ptrSavedPos = NULL;
    newScript->frameCounter = 0.0f;
    newScript->unk_158 = 0;
    newScript->timeScale = GlobalTimeRate;
 
    scriptListCount = 0;
 
    for (i = 0; i < ARRAY_COUNT(newScript->varTable); i++) {
        newScript->varTable[i] = 0;
    }
 
    for (i = 0; i < ARRAY_COUNT(newScript->varFlags); i++) {
        newScript->varFlags[i] = 0;
    }
 
    find_script_labels(newScript);
 
    if (IsUpdatingScripts && (newScript->stateFlags & EVT_FLAG_RUN_IMMEDIATELY)) {
        scriptListCount = gScriptListCount++;
        gScriptIndexList[scriptListCount] = curScriptIndex;
        gScriptIdList[scriptListCount] = newScript->id;
    }
 
    suspend_frozen_scripts(newScript);
 
    if (UniqueScriptCounter == 0) {
        UniqueScriptCounter = 1;
    }
 
    return newScript;
}

◆ start_script_in_group()

Evt * start_script_in_group	(	EvtScript *	source,
		u8	priority,
		u8	initialState,
		u8	groupFlags )

Definition at line 284 of file script_list.c.

                                                                                    {
    Evt* newScript;
    s32 scriptListCount;
    s32 curScriptIndex;
    s32 i;
 
    for (i = 0; i < MAX_SCRIPTS; i++) {
        if ((*gCurrentScriptListPtr)[i] == NULL) {
            break;
        }
    }
 
    ASSERT(i < MAX_SCRIPTS);
    curScriptIndex = i;
 
    (*gCurrentScriptListPtr)[curScriptIndex] = newScript = heap_malloc(sizeof(*newScript));
    gNumScripts++;
    ASSERT(newScript != NULL);
 
    newScript->stateFlags = flags | EVT_FLAG_ACTIVE;
    newScript->curOpcode = EVT_OP_INTERNAL_FETCH;
    newScript->priority = priority;
    newScript->id = UniqueScriptCounter++;
    newScript->ptrNextLine = (Bytecode*)source;
    newScript->ptrFirstLine = (Bytecode*)source;
    newScript->ptrCurLine = (Bytecode*)source;
    newScript->userData = NULL;
    newScript->blockingParent = NULL;
    newScript->childScript = NULL;
    newScript->parentScript = NULL;
    newScript->owner1.actorID = -1;
    newScript->owner2.npcID = -1;
    newScript->loopDepth = -1;
    newScript->switchDepth = -1;
    newScript->groupFlags = groupFlags;
    newScript->ptrSavedPos = NULL;
    newScript->frameCounter = 0.0f;
    newScript->unk_158 = 0;
    newScript->timeScale = GlobalTimeRate;
 
    scriptListCount = 0;
 
    for (i = 0; i < ARRAY_COUNT(newScript->varTable); i++) {
        newScript->varTable[i] = 0;
    }
    for (i = 0; i < ARRAY_COUNT(newScript->varFlags); i++) {
        newScript->varFlags[i] = 0;
    }
 
    find_script_labels(newScript);
 
    if (IsUpdatingScripts && (newScript->stateFlags & EVT_FLAG_RUN_IMMEDIATELY)) {
        scriptListCount = gScriptListCount++;
        gScriptIndexList[scriptListCount] = curScriptIndex;
        gScriptIdList[scriptListCount] = newScript->id;
    }
 
    suspend_frozen_scripts(newScript);
 
    if (UniqueScriptCounter == 0) {
        UniqueScriptCounter = 1;
    }
 
    return newScript;
}

Referenced by evt_handle_exec1(), evt_handle_exec1_get_id(), evt_handle_thread(), exec_ShakeCam1(), exec_ShakeCamX(), load_map_by_IDs(), and update_encounters_post_battle().

◆ get_player_normal_yaw()

f32 get_player_normal_yaw ( void )

Definition at line 657 of file 43F0.c.

                                {
    return atan2(0, 0, gGameStatusPtr->playerGroundTraceNormal.x, gGameStatusPtr->playerGroundTraceNormal.z);
}

Referenced by player_raycast_down(), and update_player_shadow().

◆ set_standard_shadow_scale()

void set_standard_shadow_scale	(	Shadow *	shadow,
		f32	scale )

Definition at line 1674 of file entity.c.

                                                           {
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        shadow->scale.x = 0.13 - (height / 2600.0f);
    } else {
        shadow->scale.x = 0.12 - (height / 3600.0f);
    }
 
    if (shadow->scale.x < 0.01) {
        shadow->scale.x = 0.01f;
    }
    shadow->scale.z = shadow->scale.x;
}

Referenced by make_item_entity(), make_item_entity_at_player(), update_item_entities(), update_nonplayer_actor_shadow(), update_player_actor_shadow(), and update_player_shadow().

◆ set_npc_shadow_scale()

void set_npc_shadow_scale	(	Shadow *	shadow,
		f32	height,
		f32	npcRadius )

Definition at line 1687 of file entity.c.

                                                                     {
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        shadow->scale.x = 0.13 - (height / 2600.0f);
    } else {
        shadow->scale.x = 0.12 - (height / 3600.0f);
    }
 
    if (shadow->scale.x < 0.01) {
        shadow->scale.x = 0.01f;
    }
 
    if (npcRadius > 60.0f) {
        shadow->scale.z = shadow->scale.x * 2.0f;
    } else {
        shadow->scale.z = shadow->scale.x;
    }
}

Referenced by update_npcs().

◆ set_npc_animation()

void set_npc_animation	(	Npc *	npc,
		u32	animID )

Definition at line 18 of file npc_api.c.

                                             {
    PlayerData* playerData = &gPlayerData;
 
    if (PARTNER_ANIM_STILL <= animID && animID <= PARTNER_ANIM_HURT) {
        npc->curAnim = gPartnerAnimations[playerData->curPartner].anims[animID - PARTNER_ANIM_STILL];
    } else if (ENEMY_ANIM_IDLE <= animID && animID <= ENEMY_ANIM_F) {
        npc->curAnim = get_enemy(npc->npcID)->animList[animID - ENEMY_ANIM_IDLE];
    } else {
        npc->curAnim = animID;
    }
}

Referenced by _show_message().

◆ set_peach_shadow_scale()

void set_peach_shadow_scale	(	Shadow *	shadow,
		f32	scale )

Definition at line 1705 of file entity.c.

                                                       {
    PlayerStatus* playerStatus = &gPlayerStatus;
    f32 phi_f2 = 0.12f;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        switch (playerStatus->anim) {
            case ANIM_Peach2_Carried:
            case ANIM_Peach2_Thrown:
            case ANIM_Peach2_Land:
            case ANIM_Peach3_TiedSideways:
                shadow->scale.x = 0.26f - (scale / 2600.0f);
                if (shadow->scale.x < 0.01) {
                    shadow->scale.x = 0.01f;
                }
                shadow->scale.z = 0.13f - (scale / 2600.0f);
                if (shadow->scale.z < 0.01) {
                    shadow->scale.z = 0.01f;
                }
                return;
        }
 
        phi_f2 = 0.16f;
    }
 
    shadow->scale.x = phi_f2 - (scale / 3600.0f);
    if (shadow->scale.x < 0.01) {
        shadow->scale.x = 0.01f;
    }
    shadow->scale.z = shadow->scale.x;
}

Referenced by update_player_shadow().

◆ is_block_on_ground()

s32 is_block_on_ground ( Entity * block )

Definition at line 1736 of file entity.c.

                                      {
    f32 x = block->pos.x;
    f32 y = block->pos.y;
    f32 z = block->pos.z;
    f32 hitYaw;
    f32 hitPitch;
    f32 hitLength;
    s32 ret;
 
    entity_raycast_down(&x, &y, &z, &hitYaw, &hitPitch, &hitLength);
 
    ret = hitLength;
    if (ret == 32767) {
        ret = FALSE;
    }
 
    return ret;
}

Referenced by entity_base_block_idle(), entity_ItemBlock_replace_with_inactive(), and entity_shattering_init_pieces().

◆ set_actor_anim()

void set_actor_anim	(	s32	actorID,
		s32	partID,
		AnimID	animID )

Definition at line 1005 of file 190B20.c.

                                                            {
    if ((s32) animID >= 0) {
        Actor* actor = get_actor(actorID);
        ActorPart* part;
 
        switch (actorID & ACTOR_CLASS_MASK) {
            case ACTOR_CLASS_PLAYER:
                part = &actor->partsTable[0];
                if (part->curAnimation != animID) {
                    part->curAnimation = animID;
                    spr_update_player_sprite(PLAYER_SPRITE_MAIN, animID, part->animationRate);
                }
                break;
            case ACTOR_CLASS_PARTNER:
                if (partID != 0) {
                    part = get_actor_part(actor, partID);
 
                    if (part == NULL) {
                        part = &actor->partsTable[0];
                    }
                } else {
                    part = &actor->partsTable[0];
                }
 
                if (part->curAnimation != animID) {
                    part->curAnimation = animID;
                    spr_update_sprite(part->spriteInstanceID, animID, part->animationRate);
                    part->animNotifyValue = spr_get_notify_value(part->spriteInstanceID);
                }
                break;
            case ACTOR_CLASS_ENEMY:
                part = get_actor_part(actor, partID);
                if (part->curAnimation != animID) {
                    part->curAnimation = animID;
                    spr_update_sprite(part->spriteInstanceID, animID, part->animationRate);
                    part->animNotifyValue = spr_get_notify_value(part->spriteInstanceID);
                }
                break;
        }
    }
}

Referenced by btl_set_player_idle_anims(), btl_state_update_celebration(), btl_state_update_partner_menu(), btl_state_update_peach_menu(), btl_state_update_player_menu(), and btl_state_update_twink_menu().

◆ set_actor_anim_rate()

void set_actor_anim_rate	(	s32	actorID,
		s32	partID,
		f32	rate )

Definition at line 1068 of file 190B20.c.

                                                            {
    Actor* actor = get_actor(actorID);
    ActorPart* part;
 
    switch (actorID & ACTOR_CLASS_MASK) {
        case ACTOR_CLASS_PARTNER:
            if (partID != 0) {
                part = get_actor_part(actor, partID);
                if (part != NULL) {
                    part->animationRate = rate;
                    return;
                }
            }
            actor->partsTable[0].animationRate = rate;
            break;
        case ACTOR_CLASS_PLAYER:
        case ACTOR_CLASS_ENEMY:
            part = get_actor_part(actor, partID);
            part->animationRate = rate;
            break;
    }
}

◆ mdl_group_set_visibility()

void mdl_group_set_visibility	(	u16	treeIndex,
		s32	flags,
		s32	mode )

Definition at line 3636 of file model.c.

                                                                  {
    s32 maxGroupIndex = -1;
    s32 minGroupIndex;
    s32 modelIndex = (*gCurrentModelTreeNodeInfo)[treeIndex].modelIndex;
    s32 siblingIndex;
    s32 i;
 
    if (modelIndex < MAX_MODELS - 1) {
        minGroupIndex = maxGroupIndex = modelIndex;
    } else {
        s32 treeDepth = (*gCurrentModelTreeNodeInfo)[treeIndex].treeDepth;
        for (i = treeIndex - 1; i >= 0; i--) {
            if ((*gCurrentModelTreeNodeInfo)[i].treeDepth <= treeDepth) {
                break;
            }
 
            siblingIndex = (*gCurrentModelTreeNodeInfo)[i].modelIndex;
 
            if (siblingIndex < MAX_MODELS - 1) {
                if (maxGroupIndex == -1) {
                    maxGroupIndex = siblingIndex;
                }
                minGroupIndex = siblingIndex;
            }
        }
    }
 
    if (mode < 2) {
        for (i = minGroupIndex; i <= maxGroupIndex; i++) {
            Model* model = (*gCurrentModels)[i];
            if (mode != MODEL_GROUP_HIDDEN) {
                model->flags &= ~flags;
            } else {
                model->flags |= flags;
            }
        }
    } else {
        for (i = 0; i < minGroupIndex; i++) {
            Model* model = (*gCurrentModels)[i];
            if (mode == MODEL_GROUP_OTHERS_VISIBLE) {
                model->flags &= ~flags;
            } else {
                model->flags |= flags;
            }
        }
        for (i = maxGroupIndex + 1; i < MAX_MODELS; i++) {
            Model* model = (*gCurrentModels)[i];
            if (model != NULL) {
                if (mode == MODEL_GROUP_OTHERS_VISIBLE) {
                    model->flags &= ~flags;
                } else {
                    model->flags |= flags;
                }
            }
        }
    }
}

◆ init_enter_world_shared()

void init_enter_world_shared ( void )

Definition at line 32 of file state_map_transitions.c.

                                   {
    gMapTransitionState = ENTER_WORLD_LOAD_MAP;
    gMapTransitionStateTime = 4;
    gGameStatusPtr->exitTangent = 0.0f;
    gMapTransitionAlpha = 255;
    nuContRmbForceStopEnd();
    update_exit_map_screen_overlay(&gMapTransitionAlpha);
 
    gOverrideFlags |= GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
 
    evt_set_variable(NULL, GB_Unused_EVT_01, gGameStatusPtr->unk_A9);
    gTimeFreezeMode = TIME_FREEZE_NONE;
}

Referenced by state_init_enter_demo(), and state_init_enter_world().

◆ update_enter_map_screen_overlay()

s16 update_enter_map_screen_overlay ( s16 * progress )

Definition at line 629 of file screen_overlays.c.

                                                   {
    u8 fadeInType = OVERLAY_SCREEN_COLOR;
    s32 fadeRate = STANDARD_FADE_RATE;
    u8 ret = FALSE;
 
    switch (CurrentScreenTransition) {
        case TRANSITION_END_DEMO_SCENE_WHITE:
            set_screen_overlay_color(SCREEN_LAYER_FRONT, 208, 208, 208);
            fadeRate = FAST_FADE_RATE;
            break;
        case TRANSITION_END_DEMO_SCENE_BLACK:
            fadeInType = OVERLAY_VIEWPORT_COLOR;
            fadeRate = FAST_FADE_RATE;
            break;
        case TRANSITION_BEGIN_OR_END_GAME:
        case TRANSITION_OUTRO_END_SCENE:
        case TRANSITION_SLOW_FADE_TO_WHITE:
        case TRANSITION_MARIO_WHITE:
        case TRANSITION_MARIO_BLACK:
            fadeInType = OVERLAY_VIEWPORT_COLOR;
            fadeRate = SLOW_FADE_RATE;
            break;
        case TRANSITION_STANDARD:
        case TRANSITION_TOY_TRAIN:
        case TRANSITION_BEGIN_OR_END_CHAPTER:
        case TRANSITION_PEACH_CAPTURED:
        case TRANSITION_GET_STAR_CARD:
            fadeInType = OVERLAY_VIEWPORT_COLOR;
            break;
        case TRANSITION_ENTER_WORLD:
        case TRANSITION_END_CHAPTER_INTERRUPTED:
            fadeInType = OVERLAY_VIEWPORT_MARIO;
            break;
        case TRANSITION_AFTER_SAVE_PROMPT:
            fadeInType = OVERLAY_VIEWPORT_STAR;
            fadeRate = SLOW_FADE_RATE;
            break;
        case TRANSITION_END_PEACH_INTERLUDE:
            fadeInType = OVERLAY_VIEWPORT_MARIO;
            fadeRate = SLOW_FADE_RATE;
            break;
        case TRANSITION_SLOW_BLUR_MOTION:
            set_screen_overlay_center(SCREEN_LAYER_FRONT, 0, 15, 28);
            set_screen_overlay_center(SCREEN_LAYER_FRONT, 1, 305, 156);
            set_screen_overlay_params_front(OVERLAY_BLUR, *progress);
            fadeRate = VERY_SLOW_FADE_RATE;
            break;
    }
 
    if (CurrentScreenTransition != TRANSITION_SLOW_BLUR_MOTION) {
        set_screen_overlay_params_front(fadeInType, *progress);
    }
 
    if (*progress == 0) {
        ret = TRUE;
    }
 
    *progress -= fadeRate;
 
    if (*progress < 0) {
        *progress = 0;
    }
 
    return ret;
}

Referenced by state_step_change_map(), and state_step_enter_world().

◆ update_exit_map_screen_overlay()

s16 update_exit_map_screen_overlay ( s16 * progress )

Definition at line 506 of file screen_overlays.c.

                                                  {
    u8 overlayColor;
    u8 fadeOutType = OVERLAY_SCREEN_COLOR;
    u8 r = 0;
    u8 g = 0;
    u8 b = 0;
    s16 t = 0;
    s32 fadeRate = STANDARD_FADE_RATE;
 
    switch (CurrentScreenTransition) {
        case TRANSITION_STANDARD:
            fadeOutType = OVERLAY_VIEWPORT_COLOR;
            break;
        case TRANSITION_TOY_TRAIN:
            fadeOutType = OVERLAY_SCREEN_COLOR;
            break;
        case TRANSITION_END_DEMO_SCENE_BLACK:
            fadeOutType = OVERLAY_VIEWPORT_COLOR;
            fadeRate = FAST_FADE_RATE;
            break;
        case TRANSITION_END_DEMO_SCENE_WHITE:
            r = g = b = 208;
            fadeOutType = OVERLAY_VIEWPORT_COLOR;
            fadeRate = SLOWER_FADE_RATE;
            if (gGameStatusPtr->demoState == DEMO_STATE_CHANGE_MAP) {
                gGameStatusPtr->nextDemoScene = LAST_DEMO_SCENE_IDX;
            }
            break;
        case TRANSITION_BEGIN_OR_END_GAME:
        case TRANSITION_OUTRO_END_SCENE:
            fadeOutType = OVERLAY_VIEWPORT_COLOR;
            fadeRate = SLOW_FADE_RATE;
            break;
        case TRANSITION_BEGIN_OR_END_CHAPTER:
            r = g = b = 208;
            fadeOutType = OVERLAY_VIEWPORT_COLOR;
            break;
        case TRANSITION_SLOW_FADE_TO_WHITE:
            if (gGameStatusPtr->demoState == DEMO_STATE_CHANGE_MAP) {
                gGameStatusPtr->nextDemoScene = LAST_DEMO_SCENE_IDX;
            }
            r = g = b = 208;
            fadeOutType = OVERLAY_VIEWPORT_COLOR;
            fadeRate = SLOW_FADE_RATE;
            break;
        case TRANSITION_AFTER_SAVE_PROMPT:
        case TRANSITION_END_CHAPTER_INTERRUPTED:
            r = g = b = 208;
            fadeOutType = OVERLAY_VIEWPORT_COLOR;
            fadeRate = SLOW_FADE_RATE;
            break;
        case TRANSITION_GET_STAR_CARD:
            r = g = b = 208;
            fadeOutType = OVERLAY_VIEWPORT_COLOR;
            fadeRate = FAST_FADE_RATE;
            break;
        case TRANSITION_ENTER_WORLD:
            set_screen_overlay_alpha(SCREEN_LAYER_FRONT, 0.0f);
            fadeOutType = OVERLAY_VIEWPORT_MARIO;
            break;
        case TRANSITION_MARIO_WHITE:
            r = g = b = 208;
            set_screen_overlay_alpha(SCREEN_LAYER_FRONT, 0.0f);
            fadeOutType = OVERLAY_VIEWPORT_MARIO;
            fadeRate = SLOW_FADE_RATE;
            break;
        case TRANSITION_MARIO_BLACK:
            set_screen_overlay_alpha(SCREEN_LAYER_FRONT, 0.0f);
            fadeOutType = OVERLAY_VIEWPORT_MARIO;
            fadeRate = SLOW_FADE_RATE;
            break;
        case TRANSITION_END_PEACH_INTERLUDE:
            set_screen_overlay_alpha(SCREEN_LAYER_FRONT, 160.0f);
            r = g = b = 208;
            fadeOutType = OVERLAY_VIEWPORT_STAR;
            fadeRate = SLOW_FADE_RATE;
            break;
        case TRANSITION_PEACH_CAPTURED:
            set_screen_overlay_alpha(SCREEN_LAYER_FRONT, 0.0f);
            fadeOutType = OVERLAY_VIEWPORT_STAR;
            fadeRate = SLOW_FADE_RATE;
            break;
        case TRANSITION_SLOW_BLUR_MOTION:
            set_screen_overlay_center(SCREEN_LAYER_FRONT, 0, 15, 28);
            set_screen_overlay_center(SCREEN_LAYER_FRONT, 1, 305, 156);
            set_screen_overlay_params_front(OVERLAY_BLUR, 255.0f);
            *progress = 255;
            return 1;
    }
 
    if (CurrentScreenTransition == TRANSITION_OUTRO_END_SCENE) {
        overlayColor = ((255 - *progress) * 208) / 255;
        set_screen_overlay_color(SCREEN_LAYER_FRONT, overlayColor, overlayColor, overlayColor);
        set_screen_overlay_params_front(fadeOutType, 255.0f);
        if (*progress == 255) {
            return 1;
        }
 
        *progress += fadeRate;
        if (*progress > 255) {
            *progress = 255;
        }
    } else {
        set_screen_overlay_color(t, r, g, b);
 
        if (t == 0) {
            set_screen_overlay_params_front(fadeOutType, *progress);
        } else {
            set_screen_overlay_params_back(fadeOutType, *progress);
        }
 
        if (*progress == 255) {
            return 1;
        }
 
        *progress += fadeRate;
        if (*progress > 255) {
            *progress = 255;
        }
    }
    return 0;
}

Referenced by init_enter_world_shared(), state_step_change_map(), and state_step_exit_file_select().

◆ set_screen_overlay_params_front()

void set_screen_overlay_params_front	(	u8	type,
		f32	zoom )

Definition at line 358 of file screen_overlays.c.

                                                        {
    screen_overlay_frontType = type;
    screen_overlay_frontZoom = zoom;
}

Referenced by btl_state_draw_celebration(), btl_state_draw_end_battle(), btl_state_draw_end_demo_battle(), btl_state_draw_enemy_striking_first(), btl_state_draw_first_stike(), btl_state_draw_normal_start(), btl_state_draw_partner_striking_first(), btl_state_update_normal_start(), btl_update(), draw_encounters_post_battle(), draw_encounters_pre_battle(), load_demo_battle(), startup_fade_screen_update(), state_init_demo(), state_step_change_map(), state_step_enter_world(), state_step_game_over(), state_step_intro(), update_encounters_post_battle(), update_encounters_pre_battle(), update_enter_map_screen_overlay(), and update_exit_map_screen_overlay().

◆ set_screen_overlay_params_back()

void set_screen_overlay_params_back	(	u8	type,
		f32	zoom )

Definition at line 363 of file screen_overlays.c.

                                                       {
    screen_overlay_backType = type;
    screen_overlay_backZoom = zoom;
}

Referenced by btl_state_update_normal_start(), btl_update(), draw_encounters_pre_battle(), state_init_intro(), state_step_intro(), and update_exit_map_screen_overlay().

◆ set_screen_overlay_alpha()

void set_screen_overlay_alpha	(	s32	layer,
		f32	alpha )

Definition at line 439 of file screen_overlays.c.

                                                    {
    switch (layer) {
        case SCREEN_LAYER_FRONT:
        case SCREEN_LAYER_BACK:
            ScreenOverlays[layer].alpha = alpha;
            break;
    }
}

Referenced by draw_encounters_pre_battle(), and update_exit_map_screen_overlay().

◆ get_screen_overlay_params()

void get_screen_overlay_params	(	s32	layer,
		u8 *	type,
		f32 *	zoom )

Definition at line 368 of file screen_overlays.c.

                                                               {
    switch (layer) {
        case SCREEN_LAYER_FRONT:
            *type = screen_overlay_frontType;
            *zoom = screen_overlay_frontZoom;
            break;
        case SCREEN_LAYER_BACK:
            *type = screen_overlay_backType;
            *zoom = screen_overlay_backZoom;
            break;
    }
}

Referenced by btl_update(), and create_target_list().

◆ set_screen_overlay_color()

void set_screen_overlay_color	(	s32	layer,
		u8	r,
		u8	g,
		u8	b )

Definition at line 381 of file screen_overlays.c.

                                                           {
    switch (layer) {
        case SCREEN_LAYER_FRONT:
        case SCREEN_LAYER_BACK:
            ScreenOverlays[layer].color.r = r;
            ScreenOverlays[layer].color.g = g;
            ScreenOverlays[layer].color.b = b;
            break;
    }
}

Referenced by btl_state_draw_end_demo_battle(), btl_state_draw_normal_start(), btl_state_update_end_battle(), btl_state_update_normal_start(), btl_update(), draw_encounters_post_battle(), draw_encounters_pre_battle(), startup_fade_screen_update(), state_init_intro(), state_step_intro(), update_enter_map_screen_overlay(), and update_exit_map_screen_overlay().

◆ set_screen_overlay_center()

void set_screen_overlay_center	(	s32	layer,
		s32	arg1,
		s32	screenPosX,
		s32	screenPosY )

Definition at line 392 of file screen_overlays.c.

                                                                                    {
    switch (layer) {
        case SCREEN_LAYER_FRONT:
        case SCREEN_LAYER_BACK:
            switch (arg1) {
                case 0:
                    ScreenOverlays[layer].screenPos[0][0] = screenPosX;
                    ScreenOverlays[layer].screenPos[0][1] = screenPosY;
                    break;
                case 1:
                    ScreenOverlays[layer].screenPos[1][0] = screenPosX;
                    ScreenOverlays[layer].screenPos[1][1] = screenPosY;
                    break;
            }
            break;
    }
}

Referenced by btl_state_update_end_battle(), draw_encounters_pre_battle(), update_enter_map_screen_overlay(), and update_exit_map_screen_overlay().

◆ rand_int()

s32 rand_int ( s32 max )

Definition at line 531 of file 43F0.c.

                      {
    s32 ret = 0;
 
    max = abs(max);
 
    if (max != 0) {
        switch (max) {
            case 1:
                // due to the off-by-one input of 1000 and the > operator being used,
                // there is a 501/1001 chance of returning 0 and a 500/1001 chance of returning 1
                // (assuming statistical randomness of rand_int_internal).
                ret = rand_int_internal(1000) > 500;
                break;
            default:
                ret = rand_int_internal(max);
                break;
            case 100:
                ret = rand_int_internal(1009) / 10;
                break;
        }
    }
 
    return ret;
}

◆ sort_consumables()

void sort_consumables ( void )

Bubbles up player inventory items such that all ITEM_NONE values are at the bottom.

Definition at line 410 of file inventory.c.

                            {
    s32 i, j;
 
    for (i = ARRAY_COUNT(gPlayerData.invItems) - 2; i >= 0; i--) {
        // leave ITEM_NONE at the end of the list alone
        if (gPlayerData.invItems[i] == ITEM_NONE) {
            continue;
        }
        // swap any other ITEM_NONE to the end of the list
        for (j = ARRAY_COUNT(gPlayerData.invItems) - 1; i < j; j--) {
            if (gPlayerData.invItems[j] == ITEM_NONE) {
                gPlayerData.invItems[j] = gPlayerData.invItems[i];
                gPlayerData.invItems[i] = ITEM_NONE;
                break;
            }
        }
    }
}

Referenced by add_item(), remove_consumable(), remove_item(), and update_item_entity_pickup().

◆ is_ability_active()

s32 is_ability_active ( s32 arg0 )

Definition at line 1736 of file inventory.c.

                                   {
    PlayerData* playerData = &gPlayerData;
    s32 attackFXArray[6];
    s32 attackFXIndex;
    s32 badgeItemID;
    s32 badgeMoveID;
    s32 ret;
    s32 i;
 
    ret = 0;
    attackFXIndex = 0;
 
    for (i = 0; i < ARRAY_COUNT(attackFXArray); i++) {
        attackFXArray[i] = 0;
    }
 
    if (gGameStatusPtr->peachFlags & PEACH_FLAG_IS_PEACH) {
        return 0;
    }
 
    for (i = 0; i < ARRAY_COUNT(playerData->equippedBadges); i++) {
        badgeItemID = playerData->equippedBadges[i];
        if (badgeItemID == ITEM_NONE)
            continue;
 
        badgeMoveID = gItemTable[badgeItemID].moveID;
 
        switch (ability) {
            case ABILITY_DODGE_MASTER:
                if (badgeMoveID == MOVE_DODGE_MASTER) {
                    ret++;
                }
                break;
            case ABILITY_SPIKE_SHIELD:
                if (badgeMoveID == MOVE_SPIKE_SHIELD) {
                    ret++;
                }
                break;
            case ABILITY_FIRST_ATTACK:
                if (badgeMoveID == MOVE_FIRST_ATTACK) {
                    ret++;
                }
                break;
            case ABILITY_HP_PLUS:
                if (badgeMoveID == MOVE_HP_PLUS) {
                    ret++;
                }
                break;
            case ABILITY_DOUBLE_DIP:
                if (badgeMoveID == MOVE_DOUBLE_DIP) {
                    ret++;
                }
                break;
            case ABILITY_MYSTERY_SCROLL:
                if (badgeMoveID == MOVE_MYSTERY_SCROLL) {
                    ret++;
                }
                if (playerData->hasActionCommands) {
                    ret++;
                }
                break;
            case ABILITY_FIRE_SHIELD:
                if (badgeMoveID == MOVE_FIRE_SHIELD) {
                    ret++;
                }
                break;
            case ABILITY_PRETTY_LUCKY:
                if (badgeMoveID == MOVE_PRETTY_LUCKY) {
                    ret++;
                }
                break;
            case ABILITY_HP_DRAIN:
                if (badgeMoveID == MOVE_HP_DRAIN) {
                    ret++;
                }
                break;
            case ABILITY_ALL_OR_NOTHING:
                if (badgeMoveID == MOVE_ALLOR_NOTHING) {
                    ret++;
                }
                break;
            case ABILITY_SLOW_GO:
                if (badgeMoveID == MOVE_SLOW_GO) {
                    ret++;
                }
                break;
            case ABILITY_FP_PLUS:
                if (badgeMoveID == MOVE_FP_PLUS) {
                    ret++;
                }
                break;
            case ABILITY_ICE_POWER:
                if (badgeMoveID == MOVE_ICE_POWER) {
                    ret++;
                }
                break;
            case ABILITY_FEELING_FINE:
                if (badgeMoveID == MOVE_FEELING_FINE) {
                    ret++;
                }
                break;
            case ABILITY_ATTACK_FX:
                if (badgeMoveID == MOVE_ATTACK_FX_A) {
                    attackFXArray[attackFXIndex++] = 1;
                    ret = -1;
                }
                if (badgeMoveID == MOVE_ATTACK_FX_D) {
                    attackFXArray[attackFXIndex++] = 2;
                    ret = -1;
                }
                if (badgeMoveID == MOVE_ATTACK_FX_B) {
                    attackFXArray[attackFXIndex++] = 3;
                    ret = -1;
                }
                if (badgeMoveID == MOVE_ATTACK_FX_E) {
                    attackFXArray[attackFXIndex++] = 4;
                    ret = -1;
                }
                if (badgeMoveID == MOVE_ATTACK_FX_C) {
                    attackFXArray[attackFXIndex++] = 5;
                    ret = -1;
                }
                if (badgeMoveID == MOVE_ATTACK_FX_F) {
                    attackFXArray[attackFXIndex++] = 6;
                    ret = -1;
                }
                break;
            case ABILITY_MONEY_MONEY:
                if (badgeMoveID == MOVE_MONEY_MONEY) {
                    ret++;
                }
                break;
            case ABILITY_CHILL_OUT:
                if (badgeMoveID == MOVE_CHILL_OUT_BADGE) {
                    ret++;
                }
                break;
            case ABILITY_HAPPY_HEART:
                if (badgeMoveID == MOVE_HAPPY_HEART) {
                    ret++;
                }
                break;
            case ABILITY_ZAP_TAP:
                if (badgeMoveID == MOVE_ZAP_TAP) {
                    ret++;
                }
                break;
            case ABILITY_MEGA_RUSH:
                if (badgeMoveID == MOVE_MEGA_RUSH) {
                    ret++;
                }
                break;
            case ABILITY_BERSERKER:
                if (badgeMoveID == MOVE_BERSERKER) {
                    ret++;
                }
                break;
            case ABILITY_RIGHT_ON:
                if (badgeMoveID == MOVE_RIGHT_ON) {
                    ret++;
                }
                break;
            case ABILITY_RUNAWAY_PAY:
                if (badgeMoveID == MOVE_RUNAWAY_PAY) {
                    ret++;
                }
                break;
            case ABILITY_FLOWER_SAVER:
                if (badgeMoveID == MOVE_FLOWER_SAVER) {
                    ret++;
                }
                break;
            case ABILITY_PAY_OFF:
                if (badgeMoveID == MOVE_PAY_OFF) {
                    ret++;
                }
                break;
            case ABILITY_DEFEND_PLUS:
                if (badgeMoveID == MOVE_DEFEND_PLUS) {
                    ret++;
                }
                break;
            case ABILITY_POWER_PLUS:
                if (badgeMoveID == MOVE_POWER_PLUS) {
                    ret++;
                }
                break;
            case ABILITY_REFUND:
                if (badgeMoveID == MOVE_REFUND) {
                    ret++;
                }
                break;
            case ABILITY_POWER_RUSH:
                if (badgeMoveID == MOVE_POWER_RUSH) {
                    ret++;
                }
                break;
            case ABILITY_CRAZY_HEART:
                if (badgeMoveID == MOVE_CRAZY_HEART) {
                    ret++;
                }
                break;
            case ABILITY_LAST_STAND:
                if (badgeMoveID == MOVE_LAST_STAND) {
                    ret++;
                }
                break;
            case ABILITY_CLOSE_CALL:
                if (badgeMoveID == MOVE_CLOSE_CALL) {
                    ret++;
                }
                break;
            case ABILITY_P_UP_D_DOWN:
                if (badgeMoveID == MOVE_P_UP_D_DOWN) {
                    ret++;
                }
                break;
            case ABILITY_LUCKY_DAY:
                if (badgeMoveID == MOVE_LUCKY_DAY) {
                    ret++;
                }
                break;
            case ABILITY_MEGA_HP_DRAIN:
                if (badgeMoveID == MOVE_MEGA_HP_DRAIN) {
                    ret++;
                }
                break;
            case ABILITY_P_DOWN_D_UP:
                if (badgeMoveID == MOVE_P_DOWN_D_UP) {
                    ret++;
                }
                break;
            case ABILITY_FLOWER_FANATIC:
                if (badgeMoveID == MOVE_FLOWER_FANATIC) {
                    ret++;
                }
                break;
            case ABILITY_SPEEDY_SPIN:
                if (badgeMoveID == MOVE_SPEEDY_SPIN) {
                    ret++;
                }
                break;
            case ABILITY_SPIN_ATTACK:
                if (badgeMoveID == MOVE_SPIN_ATTACK) {
                    ret++;
                }
                break;
            case ABILITY_I_SPY:
                if (badgeMoveID == MOVE_I_SPY) {
                    ret++;
                }
                break;
            case ABILITY_BUMP_ATTACK:
                if (badgeMoveID == MOVE_BUMP_ATTACK) {
                    ret++;
                }
                break;
            case ABILITY_QUICK_CHANGE:
                if (badgeMoveID == MOVE_QUICK_CHANGE) {
                    ret++;
                }
                break;
            case ABILITY_HEART_FINDER:
                if (badgeMoveID == MOVE_HEART_FINDER) {
                    ret++;
                }
                break;
            case ABILITY_FLOWER_FINDER:
                if (badgeMoveID == MOVE_FLOWER_FINDER) {
                    ret++;
                }
                break;
            case ABILITY_DIZZY_ATTACK:
                if (badgeMoveID == MOVE_DIZZY_ATTACK) {
                    ret++;
                }
                break;
            case ABILITY_FINAL_GOOMPA:
                if (badgeMoveID == MOVE_UNUSED_FINAL_GOOMPA) {
                    ret++;
                }
                break;
            case ABILITY_FINAL_BOBOMB:
                if (badgeMoveID == MOVE_UNUSED_FINAL_BOBOMB) {
                    ret++;
                }
                break;
            case ABILITY_DEEP_FOCUS:
                if (badgeMoveID == MOVE_DEEP_FOCUS) {
                    ret++;
                }
                break;
            case ABILITY_SUPER_FOCUS:
                if (badgeMoveID == MOVE_SUPER_FOCUS) {
                    ret++;
                }
                break;
            case ABILITY_KAIDEN:
                if (badgeMoveID == MOVE_KAIDEN) {
                    ret++;
                }
                break;
            case ABILITY_DAMAGE_DODGE:
                if (badgeMoveID == MOVE_DAMAGE_DODGE) {
                    ret++;
                }
                break;
            case ABILITY_HAPPY_FLOWER:
                if (badgeMoveID == MOVE_HAPPY_FLOWER) {
                    ret++;
                }
                break;
            case ABILITY_GROUP_FOCUS:
                if (badgeMoveID == MOVE_GROUP_FOCUS) {
                    ret++;
                }
                break;
            case ABILITY_PEEKABOO:
                if (badgeMoveID == MOVE_PEEKABOO) {
                    ret++;
                }
                break;
            case ABILITY_HEALTHY_HEALTHY:
                if (badgeMoveID == MOVE_HEALTHY_HEALTHY) {
                    ret++;
                }
                break;
        }
    }
 
    if (ret < 0) {
        ret = attackFXArray[rand_int(attackFXIndex - 1)];
    }
    return ret;
}

◆ is_starting_conversation()

s32 is_starting_conversation ( void )

Definition at line 2817 of file encounter.c.

                                   {
    s32 ret = gEncounterState == ENCOUNTER_STATE_PRE_BATTLE;
 
    if (gCurrentEncounter.hitType == ENCOUNTER_TRIGGER_CONVERSATION) {
        ret = TRUE;
    }
    return ret;
}

Referenced by partner_use_ability(), phys_update_jump(), should_continue_pulse_stone(), and test_item_entity_position().

◆ update_lerp()

f32 update_lerp	(	s32	easing,
		f32	start,
		f32	end,
		s32	elapsed,
		s32	duration )

Definition at line 734 of file 43F0.c.

                                                                           {
    s32 timeLeft;
    f32 absMag;
 
    if (duration == 0) {
        return end;
    }
 
    switch (easing) {
        case EASING_LINEAR:
            return start + (end - start) * elapsed / duration;
        case EASING_QUADRATIC_IN:
            return start + SQ(elapsed) * (end - start) / SQ(duration);
        case EASING_CUBIC_IN:
            return start + CUBE(elapsed) * (end - start) / CUBE(duration);
        case EASING_QUARTIC_IN:
            return start + QUART(elapsed) * (end - start) / QUART(duration);
        case EASING_COS_SLOW_OVERSHOOT:
            return end - ((end - start) * cos_rad(((f32)elapsed / duration) * PI_D * 4.0) * (duration - elapsed) *
                    (duration - elapsed)) / SQ((f32)duration);
        case EASING_COS_FAST_OVERSHOOT:
            return end - ((end - start) * cos_rad((((f32)SQ(elapsed) / duration) * PI_D * 4.0) / 15.0) * (duration - elapsed) *
                    (duration - elapsed)) / SQ((f32)duration);
        case EASING_QUADRATIC_OUT:
            timeLeft = duration - elapsed;
            return start + (end - start) - ((SQ(timeLeft) * (end - start))) / SQ(duration);
        case EASING_CUBIC_OUT:
            timeLeft = duration - elapsed;
            return start + (end - start) - ((CUBE(timeLeft) * (end - start))) / CUBE(duration);
        case EASING_QUARTIC_OUT:
            timeLeft = duration - elapsed;
            return start + (end - start) - ((QUART(timeLeft) * (end - start))) / QUART(duration);
        case EASING_COS_BOUNCE:
            absMag = cos_rad((((f32)SQ(elapsed) / duration) * PI_D * 4.0) / 40.0) * (duration - elapsed) *
                    (duration - elapsed) / SQ((f32)duration);
            if (absMag < 0.0f) {
                absMag = -absMag;
            }
            return end - (end - start) * absMag;
        case EASING_COS_IN_OUT:
            return start + (end - start) * (1.0 - cos_rad(((f32)elapsed * PI_D) / (f32)duration)) * 0.5;
        case EASING_SIN_OUT:
            return start + (end - start) * sin_rad(((f32)elapsed * (PI_D / 2)) / (f32)duration);
        case EASING_COS_IN:
            return start + (end - start) * (1.0 - cos_rad(((f32)elapsed * (PI_D / 2)) / (f32)duration));
    }
 
    return 0.0f;
}

Referenced by appendGfx_message(), FlyingMagikoopaAI_17(), msg_update_rewind_arrow(), sfx_compute_spatialized_sound_params_full(), and update_riding_physics().

◆ sin_cos_deg()

void sin_cos_deg	(	f32	rad,
		f32 *	outSinTheta,
		f32 *	outCosTheta )

Definition at line 719 of file 43F0.c.

                                                                {
    u16 binang = _wrap_trig_lookup_value(DEG_TO_BINANG(theta));
 
    *outSinTheta = sins(binang) * SHT_MINV;
    *outCosTheta = coss(binang) * SHT_MINV;
}

◆ set_main_pan_u()

void set_main_pan_u	(	s32	texPannerID,
		s32	value )

Definition at line 3815 of file model.c.

                                                {
    texPannerMainU[texPannerID] = value;
}

◆ set_main_pan_v()

void set_main_pan_v	(	s32	texPannerID,
		s32	value )

Definition at line 3819 of file model.c.

                                                {
    texPannerMainV[texPannerID] = value;
}

◆ set_aux_pan_u()

void set_aux_pan_u	(	s32	texPannerID,
		s32	value )

Definition at line 3823 of file model.c.

                                               {
    texPannerAuxU[texPannerID] = value;
}

◆ set_aux_pan_v()

void set_aux_pan_v	(	s32	texPannerID,
		s32	value )

Definition at line 3827 of file model.c.

                                               {
    texPannerAuxV[texPannerID] = value;
}

◆ enable_world_fog()

void enable_world_fog ( void )

Definition at line 3775 of file model.c.

                            {
    gFogSettings->enabled = TRUE;
}

◆ set_world_fog_dist()

void set_world_fog_dist	(	s32	start,
		s32	end )

Definition at line 3783 of file model.c.

                                            {
    gFogSettings->startDistance = start;
    gFogSettings->endDistance = end;
}

◆ set_world_fog_color()

void set_world_fog_color	(	s32	r,
		s32	g,
		s32	b,
		s32	a )

Definition at line 3788 of file model.c.

                                                     {
    gFogSettings->color.r = r;
    gFogSettings->color.g = g;
    gFogSettings->color.b = b;
    gFogSettings->color.a = a;
}

◆ is_world_fog_enabled()

s32 is_world_fog_enabled ( void )

Definition at line 3795 of file model.c.

                               {
    return gFogSettings->enabled;
}

Referenced by appendGfx_background_texture(), and tattle_cam_pre_render().

◆ get_world_fog_color()

void get_world_fog_color	(	s32 *	r,
		s32 *	g,
		s32 *	b,
		s32 *	a )

Definition at line 3804 of file model.c.

                                                         {
    *r = gFogSettings->color.r;
    *g = gFogSettings->color.g;
    *b = gFogSettings->color.b;
    *a = gFogSettings->color.a;
}

Referenced by appendGfx_background_texture(), and tattle_cam_pre_render().

◆ enable_entity_fog()

void enable_entity_fog ( void )

Definition at line 793 of file entity_model.c.

                             {
    entity_fog_enabled = 1;
}

◆ set_entity_fog_dist()

void set_entity_fog_dist	(	s32	start,
		s32	end )

Definition at line 801 of file entity_model.c.

                                           {
    entity_fog_dist_min = min;
    entity_fog_dist_max = max;
}

◆ set_entity_fog_color()

void set_entity_fog_color	(	s32	r,
		s32	g,
		s32	b,
		s32	a )

Definition at line 806 of file entity_model.c.

                                                      {
    entity_fog_red = r;
    entity_fog_green = g;
    entity_fog_blue = b;
    entity_fog_alpha = a;
}

◆ get_transform_group()

struct ModelTransformGroup * get_transform_group ( s32 index )

Definition at line 3452 of file model.c.

                                                    {
    return (*gCurrentTransformGroups)[index];
}

Referenced by disable_transform_group(), enable_transform_group(), and get_transform_group_index().

◆ mdl_make_transform_group()

void mdl_make_transform_group ( u16 modelID )

Definition at line 3513 of file model.c.

                                           {
    TreeIterPos = 0;
    mtg_FoundModelNode = NULL;
    mtg_SearchModelID = modelID;
    mtg_MaxChild = 0;
    mtg_MinChild = 0;
    func_8011B1D8(*gCurrentModelTreeRoot);
 
    if (mtg_FoundModelNode != NULL) {
        ModelTransformGroup* newMtg;
        ModelNode* node;
        ModelNodeProperty* prop;
        ModelBoundingBox* bb;
        f32 x, y, z;
        s32 i;
 
        for (i = 0; i < ARRAY_COUNT(*gCurrentTransformGroups); i++) {
            if ((*gCurrentTransformGroups)[i] == NULL) {
                break;
            }
        }
 
        (*gCurrentTransformGroups)[i] = newMtg = heap_malloc(sizeof(*newMtg));
        newMtg->flags = TRANSFORM_GROUP_FLAG_VALID;
        newMtg->groupModelID = modelID;
        newMtg->minChildModelIndex = get_model_list_index_from_tree_index(mtg_MinChild);
        newMtg->maxChildModelIndex = get_model_list_index_from_tree_index(mtg_MaxChild);
        newMtg->matrixFreshness = 0;
        newMtg->bakedMtx = NULL;
        newMtg->baseModelNode = mtg_FoundModelNode;
        guMtxIdent(&newMtg->savedMtx);
        newMtg->flags |= TRANSFORM_GROUP_FLAG_IGNORE_MATRIX;
        guMtxIdentF(newMtg->userTransformMtx);
 
        node = newMtg->baseModelNode;
 
        if (node->type != SHAPE_TYPE_GROUP) {
            prop = get_model_property(node, MODEL_PROP_KEY_RENDER_MODE);
        } else {
            prop = get_model_property(node, MODEL_PROP_KEY_GROUP_INFO);
 
            if (prop != NULL) {
                // GROUP_INFO properties always come in pairs, with the second giving the render mode
                prop++;
            }
        }
 
        if (prop != NULL) {
            newMtg->renderMode = prop->data.s;
        } else {
            newMtg->renderMode = RENDER_MODE_SURFACE_OPA;
        }
 
        bb = (ModelBoundingBox*)get_model_property(node, MODEL_PROP_KEY_BOUNDING_BOX);
        if (bb != NULL) {
            x = (bb->minX + bb->maxX) * 0.5f;
            y = (bb->minY + bb->maxY) * 0.5f;
            z = (bb->minZ + bb->maxZ) * 0.5f;
        } else {
            x = y = z = 0.0f;
        }
 
        if (newMtg->bakedMtx != NULL) {
            guMtxXFML(newMtg->bakedMtx, x, y, z, &x, &y, &z);
        }
 
        newMtg->center.x = x;
        newMtg->center.y = y;
        newMtg->center.z = z;
        enable_transform_group(modelID);
    }
}

◆ enable_transform_group()

void enable_transform_group ( u16 modelID )

Definition at line 3586 of file model.c.

                                         {
    ModelTransformGroup* group = get_transform_group(get_transform_group_index(modelID));
    s32 i;
 
    group->flags &= ~TRANSFORM_GROUP_FLAG_INACTIVE;
 
    for (i = group->minChildModelIndex; i <= group->maxChildModelIndex; i++) {
        Model* model = get_model_from_list_index(i);
 
        model->flags |= MODEL_FLAG_TRANSFORM_GROUP_MEMBER;
 
        if (model->bakedMtx != NULL) {
            model->flags |= MODEL_FLAG_MATRIX_DIRTY;
        }
    }
}

Referenced by mdl_make_transform_group().

◆ disable_transform_group()

void disable_transform_group ( u16 modelID )

Definition at line 3603 of file model.c.

                                          {
    ModelTransformGroup* group = get_transform_group(get_transform_group_index(modelID));
    s32 i;
 
    group->flags |= TRANSFORM_GROUP_FLAG_INACTIVE;
 
    for (i = group->minChildModelIndex; i <= group->maxChildModelIndex; i++) {
        Model* model = get_model_from_list_index(i);
 
        model->flags &= ~MODEL_FLAG_TRANSFORM_GROUP_MEMBER;
 
        if (model->bakedMtx != NULL) {
            model->flags |= MODEL_FLAG_MATRIX_DIRTY;
        }
    }
}

◆ set_map_transition_effect()

void set_map_transition_effect ( ScreenTransition transition )

Definition at line 494 of file screen_overlays.c.

                                                            {
    CurrentScreenTransition = transition;
}

Referenced by goto_map(), state_init_demo(), state_init_enter_world(), state_init_exit_file_select(), and state_step_demo().

◆ set_tex_panner()

void set_tex_panner	(	struct Model *	model,
		s32	texPannerID )

Definition at line 3811 of file model.c.

                                                   {
    model->texPannerID = texPannerID;
}

◆ set_custom_gfx()

void set_custom_gfx	(	s32	customGfxIndex,
		Gfx *	pre,
		Gfx *	post )

Definition at line 3843 of file model.c.

                                                             {
    (*gCurrentCustomModelGfxPtr)[customGfxIndex * 2] = pre;
    (*gCurrentCustomModelGfxPtr)[customGfxIndex * 2 + 1] = post;
}

◆ make_item_entity()

s32 make_item_entity	(	s32	itemID,
		f32	x,
		f32	y,
		f32	z,
		s32	itemSpawnMode,
		s32	pickupDelay,
		s32	angle,
		s32	pickupVar )

Definition at line 390 of file item_entity.c.

                                                                                                                          {
    s32 i;
    s32 id;
    ItemEntity* item;
    f32 hitDepth;
    Shadow* shadow;
 
    if (pickupFlagIndex <= EVT_GAME_FLAG_CUTOFF) {
        pickupFlagIndex = EVT_INDEX_OF_GAME_FLAG(pickupFlagIndex);
    }
 
    if (pickupFlagIndex > 0) {
        switch (itemSpawnMode) {
            case ITEM_SPAWN_MODE_KEY:
            case ITEM_SPAWN_MODE_TOSS_NEVER_VANISH:
            case ITEM_SPAWN_MODE_TOSS:
            case ITEM_SPAWN_MODE_TOSS_SPAWN_ONCE:
            case ITEM_SPAWN_MODE_TOSS_SPAWN_ONCE_NEVER_VANISH:
            case ITEM_SPAWN_MODE_ITEM_BLOCK_ITEM:
            case ITEM_SPAWN_MODE_ITEM_BLOCK_BADGE:
            case ITEM_SPAWN_MODE_FALL_NEVER_VANISH:
            case ITEM_SPAWN_MODE_FALL:
            case ITEM_SPAWN_MODE_FALL_SPAWN_ONCE:
            case ITEM_SPAWN_MODE_FIXED_NEVER_VANISH:
            case ITEM_SPAWN_MODE_FIXED:
            case ITEM_SPAWN_MODE_ITEM_BLOCK_COIN:
            case ITEM_SPAWN_MODE_TOSS_HIGHER_NEVER_VANISH:
                if (get_global_flag(pickupFlagIndex) != 0) {
                    return -1;
                }
                break;
        }
    }
 
    for (i = 0; i < MAX_ITEM_ENTITIES; i++) {
        if (gCurrentItemEntities[i] == NULL) {
            break;
        }
    }
 
    ASSERT(i < MAX_ITEM_ENTITIES);
 
    id = i;
    gCurrentItemEntities[id] = item = heap_malloc(sizeof(*item));
    ItemEntitiesCreated++;
    ASSERT(item != NULL);
 
    item->renderGroup = (itemID & 0xF0000) >> 16;
    if (item->renderGroup == VIS_GROUP_5) {
        item->renderGroup = -1;
    }
 
    item->spawnType = itemSpawnMode;
    item->state = ITEM_PHYSICS_STATE_INIT;
    item->pos.x = x;
    item->pos.y = y;
    item->pos.z = z;
 
    itemID &= 0xFFFF;
 
    item->flags = (ITEM_ENTITY_FLAG_CAM0 | ITEM_ENTITY_FLAG_CAM1 | ITEM_ENTITY_FLAG_CAM2);
    item->flags |= ITEM_ENTITY_FLAG_10;
    item->flags |= ITEM_ENTITY_FLAG_JUST_SPAWNED;
    item->pickupMsgFlags = 0;
    item->boundVar = pickupFlagIndex;
    item->itemID = itemID;
    item->physicsData = NULL;
    item->pickupDelay = pickupDelay;
    item->scale = 1.0f;
    item->spawnAngle = angle;
    item->shadowIndex = -1;
    item->nextUpdate = 1;
    item->lastPos.x = -9999;
    item->lastPos.y = -9999;
    item->lastPos.z = -9999;
    ItemSpawnWithinPlayerPickupDelay = 30;
 
    item->flags |= ITEM_ENTITY_RESIZABLE;
    if (gItemTable[itemID].typeFlags & ITEM_TYPE_FLAG_ENTITY_FULLSIZE) {
        item->flags |= ITEM_ENTITY_FLAG_FULLSIZE;
        item->flags &= ~ITEM_ENTITY_RESIZABLE;
    }
 
    if (ItemEntityAlternatingSpawn != 0) {
        item->flags |= ITEM_ENTITY_FLAG_ODD_SPAWN_PARITY;
    }
    ItemEntityAlternatingSpawn = 1 - ItemEntityAlternatingSpawn;
 
    switch (item->spawnType) {
        case ITEM_SPAWN_MODE_KEY:
            item->flags |= ITEM_ENTITY_FLAG_SAVE_ON_RECEIPT;
            break;
        case ITEM_SPAWN_MODE_DECORATION:
        case ITEM_SPAWN_MODE_TOSS_SPAWN_ALWAYS:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            break;
        case ITEM_SPAWN_MODE_INVISIBLE:
            item->flags |= ITEM_ENTITY_FLAG_INVISIBLE;
            break;
        case ITEM_SPAWN_MODE_BATTLE_REWARD:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_TOSS_LOWER;
            item->spawnType = ITEM_SPAWN_MODE_TOSS_SPAWN_ALWAYS;
            break;
        case ITEM_SPAWN_MODE_TOSS_NEVER_VANISH:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_SAVE_ON_TOUCH;
            item->flags |= ITEM_ENTITY_FLAG_NEVER_VANISH;
            item->spawnType = ITEM_SPAWN_MODE_TOSS_SPAWN_ALWAYS;
            break;
        case ITEM_SPAWN_MODE_TOSS:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_SAVE_ON_TOUCH;
            item->spawnType = ITEM_SPAWN_MODE_TOSS_SPAWN_ALWAYS;
            break;
        case ITEM_SPAWN_MODE_TOSS_SPAWN_ONCE:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_SAVE_ON_INIT;
            item->spawnType = ITEM_SPAWN_MODE_TOSS_SPAWN_ALWAYS;
            break;
        case ITEM_SPAWN_MODE_TOSS_SPAWN_ONCE_NEVER_VANISH:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_SAVE_ON_INIT;
            item->flags |= ITEM_ENTITY_FLAG_NEVER_VANISH;
            item->spawnType = ITEM_SPAWN_MODE_TOSS_SPAWN_ALWAYS;
            break;
        case ITEM_SPAWN_MODE_TOSS_SPAWN_ALWAYS_NEVER_VANISH:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_NEVER_VANISH;
            item->spawnType = ITEM_SPAWN_MODE_TOSS_SPAWN_ALWAYS;
            break;
        case ITEM_SPAWN_MODE_ITEM_BLOCK_ITEM:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_SAVE_ON_TOUCH;
            item->flags |= ITEM_ENTITY_FLAG_ANGLE_RELATIVE_VELOCITY;
            item->spawnType = ITEM_SPAWN_MODE_TOSS_SPAWN_ALWAYS;
            break;
        case ITEM_SPAWN_MODE_ITEM_BLOCK_BADGE:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_SAVE_ON_TOUCH;
            item->flags |= ITEM_ENTITY_FLAG_ANGLE_RELATIVE_VELOCITY;
            item->flags |= ITEM_ENTITY_FLAG_NEVER_VANISH;
            item->spawnType = ITEM_SPAWN_MODE_TOSS_SPAWN_ALWAYS;
            break;
        case ITEM_SPAWN_MODE_FALL_SPAWN_ALWAYS:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            break;
        case ITEM_SPAWN_MODE_FALL_NEVER_VANISH:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_SAVE_ON_TOUCH;
            item->flags |= ITEM_ENTITY_FLAG_NEVER_VANISH;
            item->spawnType = ITEM_SPAWN_MODE_FALL_SPAWN_ALWAYS;
            break;
        case ITEM_SPAWN_MODE_FALL:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_SAVE_ON_TOUCH;
            item->spawnType = ITEM_SPAWN_MODE_FALL_SPAWN_ALWAYS;
            break;
        case ITEM_SPAWN_MODE_FALL_SPAWN_ONCE:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_SAVE_ON_INIT;
            item->spawnType = ITEM_SPAWN_MODE_FALL_SPAWN_ALWAYS;
            break;
        case ITEM_SPAWN_MODE_FIXED_SPAWN_ALWAYS:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_NO_GRAVITY;
            item->flags |= ITEM_ENTITY_FLAG_NO_MOTION;
            break;
        case ITEM_SPAWN_MODE_FIXED_NEVER_VANISH:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_NO_GRAVITY;
            item->flags |= ITEM_ENTITY_FLAG_SAVE_ON_TOUCH;
            item->flags |= ITEM_ENTITY_FLAG_NEVER_VANISH;
            item->flags |= ITEM_ENTITY_FLAG_NO_MOTION;
            item->spawnType = ITEM_SPAWN_MODE_FIXED_SPAWN_ALWAYS;
            break;
        case ITEM_SPAWN_MODE_FIXED:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_NO_GRAVITY;
            item->flags |= ITEM_ENTITY_FLAG_SAVE_ON_TOUCH;
            item->flags |= ITEM_ENTITY_FLAG_NO_MOTION;
            item->spawnType = ITEM_SPAWN_MODE_FIXED_SPAWN_ALWAYS;
            break;
        case ITEM_SPAWN_MODE_FIXED_SPAWN_ALWAYS_NEVER_VANISH:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_NO_GRAVITY;
            item->flags |= ITEM_ENTITY_FLAG_NEVER_VANISH;
            item->flags |= ITEM_ENTITY_FLAG_NO_MOTION;
            item->spawnType = ITEM_SPAWN_MODE_FIXED_SPAWN_ALWAYS;
            break;
        case ITEM_SPAWN_MODE_TOSS_FADE1:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_1000;
            item->scale = 0.8f;
            item->flags |= ITEM_ENTITY_RESIZABLE;
            break;
        case ITEM_SPAWN_MODE_TOSS_FADE2:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_1000;
            item->flags |= ITEM_ENTITY_FLAG_TOSS_LOWER;
            item->spawnType = ITEM_SPAWN_MODE_TOSS_FADE1;
            item->scale = 0.8f;
            item->flags |= ITEM_ENTITY_RESIZABLE;
            break;
        case ITEM_SPAWN_MODE_TOSS_FADE3:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_1000;
            item->flags |= ITEM_ENTITY_FLAG_400000;
            item->spawnType = ITEM_SPAWN_MODE_TOSS_FADE1;
            item->scale = 0.8f;
            item->flags |= ITEM_ENTITY_RESIZABLE;
            break;
        case ITEM_SPAWN_MODE_TOSS_SPAWN_ALWAYS_SMALL:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->spawnType = ITEM_SPAWN_MODE_TOSS_SPAWN_ALWAYS;
            item->scale = 0.8f;
            item->flags |= ITEM_ENTITY_RESIZABLE;
            break;
        case ITEM_SPAWN_MODE_UNKNOWN_1B:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_8000;
            item->spawnType = ITEM_SPAWN_MODE_ITEM_BLOCK_SPAWN_ALWAYS;
            item->scale = 0.8f;
            item->flags |= ITEM_ENTITY_RESIZABLE;
            break;
        case ITEM_SPAWN_MODE_ITEM_BLOCK_SPAWN_ALWAYS:
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_8000;
            item->flags |= ITEM_ENTITY_FLAG_NEVER_VANISH;
            break;
        case ITEM_SPAWN_MODE_ITEM_BLOCK_COIN:
            item->spawnType = ITEM_SPAWN_MODE_ITEM_BLOCK_SPAWN_ALWAYS;
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_8000;
            item->flags |= ITEM_ENTITY_FLAG_SAVE_ON_TOUCH;
            item->flags |= ITEM_ENTITY_FLAG_NEVER_VANISH;
            break;
        case ITEM_SPAWN_MODE_TOSS_HIGHER_NEVER_VANISH:
            item->spawnType = ITEM_SPAWN_MODE_TOSS_SPAWN_ALWAYS;
            item->flags |= ITEM_ENTITY_FLAG_800000;
            item->flags |= ITEM_ENTITY_FLAG_SAVE_ON_TOUCH;
            item->flags |= ITEM_ENTITY_FLAG_NEVER_VANISH;
            item->flags |= ITEM_ENTITY_FLAG_TOSS_HIGHER;
            break;
    }
 
    switch (item->spawnType) {
        case ITEM_SPAWN_MODE_KEY:
        case ITEM_SPAWN_MODE_TOSS_SPAWN_ALWAYS:
        case ITEM_SPAWN_MODE_FALL_SPAWN_ALWAYS:
        case ITEM_SPAWN_MODE_FIXED_SPAWN_ALWAYS:
        case ITEM_SPAWN_MODE_ITEM_BLOCK_SPAWN_ALWAYS:
            item->shadowIndex = create_shadow_type(SHADOW_VARYING_CIRCLE, item->pos.x, item->pos.y, item->pos.z);
            shadow = get_shadow_by_index(item->shadowIndex);
 
            if (item->spawnType == ITEM_SPAWN_MODE_ITEM_BLOCK_SPAWN_ALWAYS) {
                shadow->flags |= ENTITY_FLAG_HIDDEN;
            }
 
            x = item->pos.x;
            y = item->pos.y + 12.0f;
            z = item->pos.z;
            hitDepth = 1000.0f;
            npc_raycast_down_sides(COLLIDER_FLAG_IGNORE_NPC, &x, &y, &z, &hitDepth);
            shadow->pos.x = x;
            shadow->pos.y = y;
            shadow->pos.z = z;
            shadow->rot.x = gGameStatusPtr->playerGroundTraceAngles.x;
            shadow->rot.y = 0.0f;
            shadow->rot.z = gGameStatusPtr->playerGroundTraceAngles.z;
            set_standard_shadow_scale(shadow, hitDepth * 0.5f);
            break;
    }
 
    if (item->pickupDelay != 0) {
        hide_item_entity(item);
    }
 
    item_entity_load(item);
 
    if (item->itemID == ITEM_COIN) {
        sparkle_script_init(item, &SparkleScript_Coin);
        sparkle_script_update(item);
    }
 
    if (item->itemID == ITEM_STAR_PIECE) {
        item->flags &= ~ITEM_ENTITY_FLAG_JUST_SPAWNED;
    }
 
    return id;
}

Referenced by entity_ItemBlock_spawn_item(), entity_TrumpetPlant_spawn_coin(), entity_WoodenCrate_shatter(), make_item_entity_delayed(), make_item_entity_nodelay(), and spawn_drops().

◆ make_item_entity_delayed()

s32 make_item_entity_delayed	(	s32	itemID,
		f32	x,
		f32	y,
		f32	z,
		s32	itemSpawnMode,
		s32	pickupDelay,
		s32	pickupVar )

Definition at line 686 of file item_entity.c.

                                                                                                                 {
    return make_item_entity(itemID, x, y, z, itemSpawnMode, pickupDelay, -1, pickupVar);
}

Referenced by update_item_entity_pickup().

◆ set_item_entity_position()

void set_item_entity_position	(	s32	itemEntityIndex,
		f32	x,
		f32	y,
		f32	z )

Definition at line 1567 of file item_entity.c.

                                                                        {
    ItemEntity* item = gCurrentItemEntities[itemEntityIndex];
 
    item->pos.x = x;
    item->pos.y = y;
    item->pos.z = z;
}

Referenced by entity_GiantChest_open().

◆ get_item_entity()

ItemEntity * get_item_entity ( s32 itemEntityIndex )

Definition at line 219 of file item_entity.c.

                                                 {
    return gCurrentItemEntities[itemEntityIndex];
}

Referenced by draw_shop_items(), entity_base_block_idle(), entity_HiddenPanel_flip_over(), entity_HiddenPanel_is_item_on_top(), and update_item_entity_pickup().

◆ make_item_entity_nodelay()

s32 make_item_entity_nodelay	(	s32	itemID,
		f32	x,
		f32	y,
		f32	z,
		s32	itemSpawnMode,
		s32	pickupVar )

Definition at line 682 of file item_entity.c.

                                                                                                {
    return make_item_entity(itemID, x, y, z, itemSpawnMode, 0, -1, pickupVar);
}

Referenced by entity_GiantChest_give_equipment(), entity_HiddenPanel_flip_over(), entity_MulticoinBlock_spawn_coin(), and entity_Munchlesia_init().

◆ set_item_entity_flags()

void set_item_entity_flags	(	s32	itemEntityIndex,
		s32	flag )

Definition at line 1530 of file item_entity.c.

                                                 {
    ItemEntity* item = gCurrentItemEntities[index];
 
    item->flags |= flags;
#if !VERSION_JP
    if (item->flags & ITEM_ENTITY_FLAG_CANT_COLLECT) {
        D_801565A8 = TRUE;
    }
#endif
}

Referenced by check_for_item_collision().

◆ clear_item_entity_flags()

void clear_item_entity_flags	(	s32	index,
		s32	flags )

Definition at line 1541 of file item_entity.c.

                                                   {
    ItemEntity* item = gCurrentItemEntities[index];
 
    item->flags &= ~flags;
}

◆ create_worker_frontUI()

s32 create_worker_frontUI	(	void(*)(void)	updateFunc,
		void(*)(void)	drawFunc )

Definition at line 63 of file worker.c.

                                                                            {
    Worker* worker;
    s32 i;
 
    for (i = 0; i < MAX_WORKERS; i++) {
        Worker* lastWorker = (*gCurrentWorkerListPtr)[i];
        if (lastWorker == NULL) {
            break;
        }
    }
    ASSERT(i < MAX_WORKERS);
 
    (*gCurrentWorkerListPtr)[i] = worker = heap_malloc(sizeof(*worker));
    ASSERT(worker != NULL);
 
    worker->flags = WORKER_FLAG_1 | WORKER_FLAG_SKIP_DRAW_UNTIL_UPDATE | WORKER_FLAG_FRONT_UI;
    worker->update = updateFunc;
    if (updateFunc == NULL) {
        worker->update = worker_delegate_do_nothing;
    }
    worker->draw = drawFunc;
    if (drawFunc == NULL) {
        worker->draw = worker_delegate_do_nothing;
    }
 
    if (gGameStatusPtr->context != CONTEXT_WORLD) {
        i |= BATTLE_ENTITY_ID_BIT;
    }
    return i;
}

Referenced by clear_item_entity_data(), create_action_command_ui_worker(), create_battle_popup_menu(), create_shop_popup_menu(), create_standard_popup_menu(), and partner_reset_data().

◆ get_worker()

Worker * get_worker ( s32 idx )

Definition at line 186 of file worker.c.

                            {
    return (*gCurrentWorkerListPtr)[idx & ~BATTLE_ENTITY_ID_BIT];
}

Referenced by partner_reset_data().

◆ bind_trigger_1()

Trigger * bind_trigger_1	(	EvtScript *	script,
		s32	flags,
		s32	triggerFlagIndex,
		s32	triggerVar0,
		s32	triggerVar1,
		s32	priority )

Definition at line 751 of file script_list.c.

                                      {
    return bind_trigger(script, flags, triggerFlagIndex, triggerVar0, triggerVar1, priority, 1);
}

◆ set_cam_viewport()

void set_cam_viewport	(	s16	id,
		s16	x,
		s16	y,
		s16	width,
		s16	height )

Definition at line 373 of file cam_main.c.

                                                                   {
    Camera* camera = &gCameras[id];
 
    camera->viewportW = width;
    camera->viewportH = height;
    camera->viewportStartX = x;
    camera->viewportStartY = y;
 
    camera->vp.vp.vscale[0] = 2.0f * camera->viewportW;
    camera->vp.vp.vscale[1] = 2.0f * camera->viewportH;
    camera->vp.vp.vscale[2] = 0x1FF;
    camera->vp.vp.vscale[3] = 0;
 
    camera->vp.vp.vtrans[0] = 4 * (s16) ((u16) camera->viewportStartX + (camera->viewportW / 2));
    camera->vp.vp.vtrans[1] = (s16) ((u16) camera->viewportStartY + (camera->viewportH / 2));
    camera->vp.vp.vtrans[1] = 4 * camera->vp.vp.vtrans[1];
    camera->vp.vp.vtrans[2] = 0x1FF;
    camera->vp.vp.vtrans[3] = 0;
 
    camera->vpAlt.vp.vscale[0] = 2.0f * camera->viewportW;
    camera->vpAlt.vp.vscale[1] = 2.0f * camera->viewportH;
    camera->vpAlt.vp.vscale[2] = 0x1FF;
    camera->vpAlt.vp.vscale[3] = 0;
 
    camera->vpAlt.vp.vtrans[0] = gGameStatusPtr->altViewportOffset.x + 4 * (s16) ((u16) camera->viewportStartX + (camera->viewportW / 2));
    camera->vpAlt.vp.vtrans[1] = gGameStatusPtr->altViewportOffset.y + 4 * (s16) ((u16) camera->viewportStartY + (camera->viewportH / 2));
    camera->vpAlt.vp.vtrans[2] = 0x200;
    camera->vpAlt.vp.vtrans[3] = 0;
}

Referenced by hud_element_setup_cam(), initialize_next_camera(), load_map_by_IDs(), state_init_file_select(), state_init_logos(), state_init_title_screen(), and state_step_demo().

◆ disable_player_shadow()

void disable_player_shadow ( void )

Definition at line 968 of file 77480.c.

                                 {
    get_shadow_by_index(gPlayerStatus.shadowID)->flags |= ENTITY_FLAG_HIDDEN;
}

Referenced by action_update_use_tweester(), entity_BlueWarpPipe_enter_pipe_init(), and func_802BC0B8_E2E9E8().

◆ move_player()

void move_player	(	s32	duration,
		f32	heading,
		f32	speed )

Definition at line 57 of file 7BB60.c.

                                                       {
    gPlayerStatus.flags |= PS_FLAG_CUTSCENE_MOVEMENT;
    gPlayerStatus.heading = heading;
    gPlayerStatus.moveFrames = duration;
    gPlayerStatus.curSpeed = speed;
 
    if (!(gPlayerStatus.animFlags & PA_FLAG_RIDING_PARTNER)) {
        set_action_state(speed > gPlayerStatus.walkSpeed ? ACTION_STATE_RUN : ACTION_STATE_WALK);
    }
}

Referenced by entity_BlueWarpPipe_set_player_move_to_center().

◆ enable_player_input()

s32 enable_player_input ( void )

Definition at line 998 of file 77480.c.

                              {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    playerStatus->inputDisabledCount--;
    if (playerStatus->inputDisabledCount == 0) {
        playerStatus->flags &= ~PS_FLAG_INPUT_DISABLED;
    }
    return playerStatus->inputDisabledCount;
}

Referenced by _use_partner_ability(), action_update_spin_jump(), action_update_tornado_jump(), action_update_use_munchlesia(), action_update_use_spinning_flower(), action_update_use_tweester(), check_input_open_menus(), end_outta_sight_cleanup(), entity_Chest_enable_player_input(), entity_CymbalPlant_idle(), entity_GiantChest_await_got_item(), entity_HeartBlock_wait_for_close_tutorial(), entity_HeartBlockContent__anim_heal(), entity_SaveBlock_resume_game(), entity_SimpleSpring_enable_player_input(), entity_TriggerBlock_enable_player_input(), func_802BC3A0_E2ECD0(), handle_jumping_land_on_switch(), pre_battle(), pre_battle(), pre_battle(), pre_battle(), pre_battle(), pre_battle(), pre_battle(), SentinelAI_GrabPlayer(), set_action_state(), state_step_change_map(), state_step_enter_world(), state_step_unpause(), update_encounters_conversation(), update_encounters_post_battle(), and update_item_entity_pickup().

◆ enable_player_static_collisions()

s32 enable_player_static_collisions ( void )

Definition at line 980 of file 77480.c.

                                          {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    playerStatus->enableCollisionOverlapsCheck--;
    if (playerStatus->enableCollisionOverlapsCheck == 0) {
        playerStatus->flags &= ~PS_FLAG_NO_STATIC_COLLISION;
    }
    return playerStatus->enableCollisionOverlapsCheck;
}

Referenced by action_update_parasol(), action_update_use_munchlesia(), action_update_use_spinning_flower(), action_update_use_tweester(), entity_HiddenPanel_flip_over(), entity_StarBoxLauncher_launch(), pre_battle(), pre_battle(), and pre_battle().

◆ check_input_jump()

b32 check_input_jump ( void )

Definition at line 344 of file 7E9D0.c.

                           {
    PlayerStatus* playerStatus = &gPlayerStatus;
    CollisionStatus* collisionStatus = &gCollisionStatus;
    s32 surfaceType;
 
    if (!(playerStatus->pressedButtons & BUTTON_A)) {
        return FALSE;
    }
 
    surfaceType = get_collider_flags((u16)gCollisionStatus.curFloor) & COLLIDER_FLAGS_SURFACE_TYPE_MASK;
    if ((surfaceType == SURFACE_TYPE_SLIDE) && phys_should_player_be_sliding()) {
        return FALSE;
    }
 
    if (collisionStatus->touchingWallTrigger != 0 ||
        (playerStatus->animFlags & (PA_FLAG_SPEECH_PROMPT_AVAILABLE |
                                    PA_FLAG_INTERACT_PROMPT_AVAILABLE)))
    {
        return FALSE;
    }
 
    if ((collisionStatus->curInspect != -1) && (collisionStatus->curInspect & COLLISION_WITH_ENTITY_BIT)) {
        Entity* entity = get_entity_by_index(collisionStatus->curInspect);
 
        if (entity->flags & ENTITY_FLAG_SHOWS_INSPECT_PROMPT) {
            if ((entity->boundScriptBytecode == NULL) || (entity->flags & ENTITY_FLAG_4000)) {
                if (entity->type == ENTITY_TYPE_PINK_FLOWER ||
                    entity->type == ENTITY_TYPE_BELLBELL_PLANT ||
                    entity->type == ENTITY_TYPE_TRUMPET_PLANT)
                {
                    return FALSE;
                }
            } else {
                return FALSE;
            }
        }
    }
 
    set_action_state(ACTION_STATE_JUMP);
    return TRUE;
}

Referenced by action_update_idle(), action_update_land(), action_update_pushing_block(), action_update_run(), action_update_spin(), action_update_step_down(), action_update_step_down_land(), and action_update_walk().

◆ check_input_hammer()

b32 check_input_hammer ( void )

Definition at line 321 of file 7E9D0.c.

                             {
    PlayerStatus* playerStatus = &gPlayerStatus;
    PlayerData* playerData = &gPlayerData;
 
    if (playerStatus->pressedButtons & BUTTON_B) {
        if (playerStatus->flags & PS_FLAG_FALLING) {
            return FALSE;
        }
 
        if (gPartnerStatus.partnerActionState == PARTNER_ACTION_USE && playerData->curPartner == PARTNER_WATT) {
            return FALSE;
        }
 
        if (playerData->hammerLevel == -1) {
            return FALSE;
        }
 
        set_action_state(ACTION_STATE_HAMMER);
        return TRUE;
    }
    return FALSE;
}

Referenced by action_update_idle(), action_update_run(), action_update_spin(), and action_update_walk().

◆ resolve_npc()

Npc * resolve_npc	(	Evt *	script,
		s32	npcIdOrPtr )

Definition at line 8 of file npc_api.c.

                                              {
    if (npcIdOrPtr == NPC_SELF) {
        return get_npc_safe(script->owner2.npcID);
    } else if (npcIdOrPtr >= EVT_LIMIT) {
        return get_npc_safe(npcIdOrPtr);
    } else {
        return (Npc*) npcIdOrPtr;
    }
}

Referenced by _npc_jump_to(), and _show_message().

◆ enable_npc_blur()

void enable_npc_blur ( Npc * npc )

Definition at line 1066 of file npc.c.

                               {
    if (!(npc->flags & NPC_FLAG_MOTION_BLUR)) {
        NpcMotionBlur* motionBlur;
        s32 i;
 
        npc->flags |= NPC_FLAG_MOTION_BLUR;
 
        motionBlur = heap_malloc(sizeof(*motionBlur));
        npc->blur.motion = motionBlur;
        ASSERT(motionBlur != NULL);
        motionBlur->unused = 0;
        motionBlur->index = 0;
 
        for (i = 0; i < ARRAY_COUNT(motionBlur->posX); i++) {
            motionBlur->posX[i] = npc->pos.x;
            motionBlur->posY[i] = npc->pos.y;
            motionBlur->posZ[i] = npc->pos.z;
        }
    }
}

Referenced by partner_put_away().

◆ disable_npc_blur()

void disable_npc_blur ( Npc * npc )

Definition at line 1087 of file npc.c.

                                {
    if (npc->flags & NPC_FLAG_MOTION_BLUR) {
        npc->flags &= ~NPC_FLAG_MOTION_BLUR;
 
        heap_free(npc->blur.motion);
        npc->blur.motion = NULL;
    }
}

Referenced by free_npc(), free_npc_by_index(), partner_put_away(), pre_battle(), pre_battle(), and pre_battle().

◆ enable_partner_blur()

void enable_partner_blur ( void )

Definition at line 265 of file actor_rendering.c.

                               {
    enable_actor_blur(gBattleStatus.partnerActor);
}

◆ disable_partner_blur()

void disable_partner_blur ( void )

Definition at line 269 of file actor_rendering.c.

                                {
    disable_actor_blur(gBattleStatus.partnerActor);
}

◆ partner_initialize_data()

void partner_initialize_data ( void )

Definition at line 1032 of file partners.c.

                                   {
    PartnerStatus* partnerStatus = &gPartnerStatus;
 
    wCurrentPartnerId = 0;
    D_8010CFE0 = 0;
    NextPartnerCommand = PARTNER_CMD_NONE;
    D_8010CFC4 = 0;
    partnerStatus->actingPartner = 0;
    partnerStatus->inputDisabledCount = 0;
    partnerStatus->shouldResumeAbility = FALSE;
    partnerStatus->partnerActionState = 0;
    partnerStatus->unk_358 = 0;
    partnerStatus->partnerAction_unk_2 = FALSE;
    wPartner = NULL;
    wSavedPartnerPosX = 0;
    wSavedPartnerPosY = 0;
    wSavedPartnerPosZ = 0;
}

Referenced by state_step_startup().

◆ dist2D()

f32 dist2D	(	f32	ax,
		f32	ay,
		f32	bx,
		f32	by )

Definition at line 669 of file 43F0.c.

                                           {
    f32 xDiff = bx - ax;
    f32 yDiff = by - ay;
 
    return sqrtf(SQ(xDiff) + SQ(yDiff));
}

Referenced by _npc_jump_to(), action_update_use_spinning_flower(), action_update_use_tweester(), ai_check_fwd_collisions(), ai_check_player_dist(), AvoidPlayerAI_ChaseInit(), basic_ai_chase(), basic_ai_chase_init(), basic_ai_check_player_dist(), basic_ai_wander(), BooPatrolAI_Move(), CleftAI_ReturnHome(), CleftAI_RevUp(), ClubbaNappingAI_ReturnHome(), ClubbaNappingAI_Sleep(), entity_HiddenPanel_idle(), entity_Tweester_idle(), FlyingAI_Wander(), FlyingMagikoopaAI_15(), func_802BB0A0_E2D9D0(), func_802BB8D4_E2E204(), func_802BC0F0_E2EA20(), game_input_to_move_vector(), get_movement_from_input(), get_stick_input_radial(), get_xz_dist_to_player(), GuardAI_ReturnHome(), handle_jumping_land_on_switch(), is_point_outside_territory(), MagikoopaAI_10(), MeleeHitbox_CanSeePlayer(), msg_draw_speech_arrow(), npc_find_closest(), npc_find_closest_simple(), npc_follow_npc(), npc_update_npc_tracking(), ParatroopaAI_Windup(), partner_flying_follow_player(), partner_get_out(), partner_move_to_goal(), partner_put_away(), partner_walking_follow_player(), PatrolAI_Move(), PatrolAI_MoveInit(), PiranhaPlantAI_10(), player_input_to_move_vector(), player_jump(), render_entities(), SentinelAI_Chase(), SentinelAI_ReturnHome(), test_first_strike(), test_first_strike(), UnkDistFunc(), update_camera_unused_radial(), and update_player_shadow().

◆ dist3D()

f32 dist3D	(	f32	ax,
		f32	ay,
		f32	az,
		f32	bx,
		f32	by,
		f32	bz )

Definition at line 676 of file 43F0.c.

                                                           {
    f32 xDiff = bx - ax;
    f32 yDiff = by - ay;
    f32 zDiff = bz - az;
 
    return sqrtf(SQ(xDiff) + SQ(yDiff) + SQ(zDiff));
}

Referenced by update_triggers().

◆ add_vec2D_polar()

void add_vec2D_polar	(	f32 *	x,
		f32 *	y,
		f32	r,
		f32	theta )

Definition at line 684 of file 43F0.c.

                                                       {
    f32 sinTheta;
    f32 cosTheta;
 
    sin_cos_rad(DEG_TO_RAD(theta), &sinTheta, &cosTheta);
    *x += r * sinTheta;
    *y -= r * cosTheta;
}

Referenced by action_update_use_munchlesia(), ai_check_player_dist(), basic_ai_check_player_dist(), btl_main_menu_draw(), btl_main_menu_update(), can_dismount(), check_for_treadmill_overlaps(), ClubbaNappingAI_Sleep(), collision_main_lateral(), draw_all_status_icons(), entity_StarBoxLauncher_check_launch(), FlyingMagikoopaAI_15(), FlyingMagikoopaAI_21(), func_802BB98C_E2E2BC(), func_802BC17C_E2EAAC(), handle_jumping_land_on_switch(), MagikoopaAI_21(), offset_player_from_camera(), partner_do_player_collision(), partner_flying_follow_player(), partner_get_out(), partner_move_to_goal(), partner_walking_follow_player(), PiranhaPlantAI_10(), pre_battle(), sync_player_position(), test_item_player_collision(), update_encounters_neutral(), and update_riding_physics().

◆ bgm_set_track_volumes()

enum AuResult bgm_set_track_volumes	(	s32	playerIndex,
		s16	trackVolSet )

Definition at line 286 of file e0b30_len_b80.c.

                                                                 {
    MusicSettings* musicSetting = &gMusicSettings[playerIndex];
 
    if (!(musicSetting->flags & MUSIC_SETTINGS_FLAG_1)) {
        return AU_RESULT_OK;
    }
 
    return snd_song_set_track_volumes(musicSetting->songName, trackVolSet);
}

◆ bgm_clear_track_volumes()

enum AuResult bgm_clear_track_volumes	(	s32	playerIndex,
		s16	trackVolSet )

Definition at line 296 of file e0b30_len_b80.c.

                                                                   {
    MusicSettings* musicSetting = &gMusicSettings[playerIndex];
 
    if (!(musicSetting->flags & MUSIC_SETTINGS_FLAG_1)) {
        return AU_RESULT_OK;
    }
 
    return snd_song_clear_track_volumes(musicSetting->songName, trackVolSet);
}

◆ bgm_set_variation()

enum AuResult bgm_set_variation	(	s32	playerIndex,
		s16	arg1 )

Definition at line 306 of file e0b30_len_b80.c.

                                                      {
    MusicSettings* musicSetting = &gMusicSettings[playerIndex];
 
    if (!(musicSetting->flags & MUSIC_SETTINGS_FLAG_1)) {
        return AU_RESULT_OK;
    }
 
    return snd_set_song_variation(musicSetting->songName, arg1);
}

◆ bgm_quiet_max_volume()

void bgm_quiet_max_volume ( void )

Definition at line 323 of file e0b30_len_b80.c.

                                {
    MusicMaxVolume = 4;
}

Referenced by state_step_pause().

◆ bgm_reset_max_volume()

void bgm_reset_max_volume ( void )

Definition at line 327 of file e0b30_len_b80.c.

                                {
    MusicMaxVolume = 8;
}

Referenced by state_step_unpause().

◆ bgm_reset_volume()

void bgm_reset_volume ( void )

Definition at line 76 of file e0b30_len_b80.c.

                            {
    MusicTargetVolume = 8;
    MusicMaxVolume = 8;
}

Referenced by state_step_startup().

◆ bgm_init_music_players()

s32 bgm_init_music_players ( void )

Definition at line 316 of file e0b30_len_b80.c.

                                 {
    bgm_set_song(0, -1, 0, 250, 8);
    bgm_set_song(1, -1, 0, 250, 8);
 
    return 1;
}

Referenced by state_step_startup().

◆ bgm_set_song()

s32 bgm_set_song	(	s32	playerIndex,
		s32	songID,
		s32	variation,
		s32	fadeOutTime,
		s16	volume )

Definition at line 222 of file e0b30_len_b80.c.

                                                                                          {
    gMusicSettings[playerIndex].flags &= ~MUSIC_SETTINGS_FLAG_8;
 
    return _bgm_set_song(playerIndex, songID, variation, fadeOutTime, volume);
}

Referenced by bgm_init_music_players(), bgm_push_battle_song(), bgm_push_song(), btl_state_update_celebration(), btl_state_update_defeat(), btl_state_update_end_training_battle(), btl_state_update_run_away(), btl_state_update_victory(), state_init_exit_file_select(), state_init_title_screen(), and state_step_title_screen().

◆ bgm_set_battle_song()

void bgm_set_battle_song	(	s32	songID,
		s32	variation )

Definition at line 425 of file e0b30_len_b80.c.

                                                    {
    MusicSettings* musicSetting = gMusicSettings;
 
    musicSetting->battleSongID = songID;
    musicSetting->battleVariation = variation;
}

Referenced by update_encounters_pre_battle().

◆ bgm_push_battle_song()

void bgm_push_battle_song ( void )

Definition at line 410 of file e0b30_len_b80.c.

                                {
    MusicSettings* musicSetting = gMusicSettings;
 
    if (gGameStatusPtr->demoState == DEMO_STATE_NONE) {
        if (!(gOverrideFlags & GLOBAL_OVERRIDES_DONT_RESUME_SONG_AFTER_BATTLE)) {
            snd_ambient_pause(0, 250);
            musicSetting->savedSongID = musicSetting->songID;
            musicSetting->savedVariation = musicSetting->variation;
            musicSetting->savedSongName = musicSetting->songName;
            musicSetting->flags |= MUSIC_SETTINGS_FLAG_4;
            bgm_set_song(0, musicSetting->battleSongID, musicSetting->battleVariation, 500, 8);
        }
    }
}

Referenced by update_encounters_pre_battle().

◆ bgm_adjust_proximity()

s32 bgm_adjust_proximity	(	s32	playerIndex,
		s32	arg1,
		s16	arg2 )

Definition at line 261 of file e0b30_len_b80.c.

                                                              {
    MusicSettings* musicSetting = &gMusicSettings[playerIndex];
 
    if (!(musicSetting->flags & MUSIC_SETTINGS_FLAG_1)) {
        return FALSE;
    }
 
    if (!(musicSetting->flags & MUSIC_SETTINGS_FLAG_ENABLE_PROXIMITY_MIX)) {
        return FALSE;
    }
 
    switch (state) {
        case MUSIC_PROXIMITY_FAR:
            bgm_set_proximity_mix_far(musicSetting->songName, mix);
            break;
        case MUSIC_PROXIMITY_NEAR:
            bgm_set_proximity_mix_near(musicSetting->songName, mix);
            break;
        case MUSIC_PROXIMITY_FULL:
            bgm_set_proximity_mix_full(musicSetting->songName, mix);
            break;
    }
    return TRUE;
}

◆ func_801491E4()

void func_801491E4	(	Matrix4f	mtx,
		s32	arg1,
		s32	arg2,
		s32	arg3,
		s32	arg4,
		s32	alpha )

Definition at line 415 of file sprite_shading.c.

                                                                                    {
    gDPSetPrimColor(gMainGfxPos++, 0, 0, 0, 0, 0, alpha);
 
    if (alpha == 255) {
        gDPSetCombineMode(gMainGfxPos++, PM_CC_WINDOW_5, G_CC_PASS2);
    } else {
        gDPSetCombineMode(gMainGfxPos++, PM_CC_02, G_CC_PASS2);
    }
}

Referenced by appendGfx_item_entity(), and render_item_entities().

◆ func_8014A964()

s32 func_8014A964	(	s32	playerIndex,
		s32	songID,
		s32	variation,
		s32	fadeInTime,
		s16	arg4,
		s16	arg5 )

Definition at line 228 of file e0b30_len_b80.c.

                                                                                                                      {
    MusicSettings* musicSetting;
    s32 mapSongVariation;
 
    if (gGameStatusPtr->demoState) {
        return 1;
    }
 
    musicSetting = &gMusicSettings[playerIndex];
 
    if (!gGameStatusPtr->musicEnabled) {
        au_song_stop(musicSetting->songName);
        musicSetting->flags &= ~MUSIC_SETTINGS_FLAG_1;
        return 1;
    }
 
    mapSongVariation = bgm_get_map_default_variation(songID);
    if (mapSongVariation >= 0) {
        variation = mapSongVariation;
    }
 
    musicSetting->fadeInTime = fadeInTime;
    musicSetting->fadeStartVolume = fadeStartVolume;
    musicSetting->fadeEndVolume = fadeEndVolume;
    musicSetting->songID = songID;
    musicSetting->variation = variation;
    musicSetting->flags |= MUSIC_SETTINGS_FLAG_20;
    musicSetting->state = 1;
    musicSetting->flags &= ~MUSIC_SETTINGS_FLAG_ENABLE_PROXIMITY_MIX;
 
    return 1;
}

◆ basic_window_update()

void basic_window_update	(	s32	windowIndex,
		s32 *	flags,
		s32 *	posX,
		s32 *	posY,
		s32 *	posZ,
		f32 *	scaleX,
		f32 *	scaleY,
		f32 *	rotX,
		f32 *	rotY,
		f32 *	rotZ,
		s32 *	darkening,
		s32 *	opacity )

Definition at line 161 of file windows.c.

                                                                                       {
    Window* window = &gWindows[windowID];
    s32 counter = window->updateCounter;
 
    if (counter == 0) {
        window->flags &= ~WINDOW_FLAG_HIDDEN;
    }
 
    if (counter <= 4) {
        *flags = gWindowAppearFlags[counter];
        *scaleX = (f32)gWindowAppearScales[counter] * 0.01;
        *scaleY = (f32)gWindowAppearScales[counter] * 0.01;
        *rotZ = (4 - counter) * 3;
    } else {
        *flags = gWindowAppearFlags[4];
        *scaleX = 1.0f;
        *scaleY = 1.0f;
        *rotZ = 0.0f;
        window->flags &= ~WINDOW_FLAG_INITIAL_ANIMATION;
    }
}

Referenced by draw_shop_items(), func_800F16CC(), pause_tabs_update(), popup_menu_update(), show_coin_counter(), and update_item_entity_pickup().

◆ basic_hidden_window_update()

void basic_hidden_window_update	(	s32	windowIndex,
		s32 *	flags,
		s32 *	posX,
		s32 *	posY,
		s32 *	posZ,
		f32 *	scaleX,
		f32 *	scaleY,
		f32 *	rotX,
		f32 *	rotY,
		f32 *	rotZ,
		s32 *	darkening,
		s32 *	opacity )

Definition at line 184 of file windows.c.

                                                                                       {
    Window* window = &gWindows[windowID];
    s32 counter = window->updateCounter;
 
    if (counter <= 9) {
        *flags = gWindowDisappearFlags[counter];
        *scaleX = (f32)gWindowDisappearScales[counter] * 0.01;
        *scaleY = (f32)gWindowDisappearScales[counter] * 0.01;
        *rotZ = -counter;
    } else {
        *flags = gWindowDisappearFlags[9];
        *scaleX = 0.0f;
        *scaleY = 0.0f;
        *rotZ = 0.0f;
        window->flags &= ~WINDOW_FLAG_INITIAL_ANIMATION;
        window->flags |= WINDOW_FLAG_HIDDEN;
    }
}

Referenced by draw_shop_items(), hide_popup_menu(), update_coin_counter(), and update_item_entity_pickup().

◆ create_current_pos_target_list()

void create_current_pos_target_list ( Actor * actor )

Definition at line 472 of file 190B20.c.

                                                  {
    create_target_list(actor, FALSE);
}

Referenced by btl_init_menu_boots(), btl_init_menu_hammer(), btl_init_menu_items(), btl_init_menu_partner(), btl_state_update_partner_striking_first(), btl_state_update_player_menu(), btl_state_update_select_target(), and count_targets().

◆ create_home_target_list()

void create_home_target_list ( Actor * actor )

Definition at line 476 of file 190B20.c.

                                           {
    create_target_list(actor, TRUE);
}

◆ set_actor_yaw()

void set_actor_yaw	(	s32	actorID,
		s32	yaw )

Definition at line 1091 of file 190B20.c.

                                         {
    get_actor(actorID)->yaw = yaw;
}

◆ set_part_yaw()

void set_part_yaw	(	s32	actorID,
		s32	partID,
		s32	value )

Definition at line 1095 of file 190B20.c.

                                                      {
    get_actor_part(get_actor(actorID), partID)->yaw = value;
}

◆ add_part_decoration()

void add_part_decoration	(	ActorPart *	part,
		s32	decorationIndex,
		s32	decorationType )

Definition at line 2727 of file 190B20.c.

                                                                                   {
    if ((part->idleAnimations) && !(part->flags & ACTOR_PART_FLAG_NO_DECORATIONS)) {
        DecorationTable* decorations = part->decorationTable;
 
        _remove_part_decoration(part, decorationIndex);
        decorations->type[decorationIndex] = decorationType;
        decorations->changed[decorationIndex] = TRUE;
        decorations->state[decorationIndex] = 0;
        _add_part_decoration(part);
    }
}

Referenced by add_actor_decoration().

◆ add_actor_decoration()

void add_actor_decoration	(	Actor *	actor,
		s32	decorationIndex,
		s32	decorationType )

Definition at line 2739 of file 190B20.c.

                                                                                 {
    for (ActorPart* part = actor->partsTable; part != NULL; part = part->nextPart) {
        if (!(part->flags & (ACTOR_PART_FLAG_INVISIBLE | ACTOR_PART_FLAG_USE_ABSOLUTE_POSITION))
            && part->idleAnimations
            && !(part->flags & ACTOR_PART_FLAG_NO_DECORATIONS)
        ) {
            add_part_decoration(part, decorationIndex, decorationType);
        }
    }
}

◆ remove_part_decoration()

void remove_part_decoration	(	ActorPart *	part,
		s32	decorationIndex )

Definition at line 2750 of file 190B20.c.

                                                                  {
    _remove_part_decoration(part, decorationIndex);
}

Referenced by remove_actor_decoration().

◆ remove_actor_decoration()

void remove_actor_decoration	(	Actor *	actor,
		s32	decorationIndex )

Definition at line 2754 of file 190B20.c.

                                                                {
    for (ActorPart* part = actor->partsTable; part != NULL; part = part->nextPart) {
        if (!(part->flags & (ACTOR_PART_FLAG_INVISIBLE | ACTOR_PART_FLAG_USE_ABSOLUTE_POSITION))
            && part->idleAnimations != NULL
            && !(part->flags & ACTOR_PART_FLAG_NO_DECORATIONS)
        ) {
            remove_part_decoration(part, decorationIndex);
        }
    }
}

Referenced by btl_delete_actor(), and btl_delete_player_actor().

◆ player_team_is_ability_active()

s32 player_team_is_ability_active	(	Actor *	actor,
		s32	ability )

Definition at line 2765 of file 190B20.c.

                                                             {
    s32 actorClass = actor->actorID & ACTOR_CLASS_MASK;
    s32 hasAbility = FALSE;
 
    switch (actorClass) {
        case ACTOR_CLASS_PLAYER:
            if (!(gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE)) {
                hasAbility = is_ability_active(ability);
            }
            break;
        case ACTOR_CLASS_PARTNER:
            hasAbility = is_partner_ability_active(ability);
            break;
        case ACTOR_CLASS_ENEMY:
            break;
    }
 
    return hasAbility;
}

Referenced by appendGfx_player_actor(), btl_init_menu_boots(), btl_init_menu_hammer(), btl_init_menu_partner(), btl_state_update_change_partner(), btl_state_update_partner_menu(), btl_state_update_player_menu(), calc_enemy_damage_target(), calc_enemy_test_target(), calc_partner_test_enemy(), calc_player_damage_enemy(), calc_player_test_enemy(), and deduct_current_move_fp().

◆ create_part_shadow()

void create_part_shadow	(	s32	actorID,
		s32	partID )

Definition at line 2785 of file 190B20.c.

                                                 {
    ActorPart* part = get_actor_part(get_actor(actorID), partID);
 
    part->flags &= ~ACTOR_PART_FLAG_NO_SHADOW;
    part->shadowIndex = create_shadow_type(SHADOW_VARYING_CIRCLE, part->curPos.x, part->curPos.y, part->curPos.z);
    part->shadowScale = part->size.x / 24.0;
}

◆ remove_part_shadow()

void remove_part_shadow	(	s32	actorID,
		s32	partID )

Definition at line 2793 of file 190B20.c.

                                                 {
    ActorPart* part = get_actor_part(get_actor(actorID), partID);
 
    part->flags |= ACTOR_PART_FLAG_NO_SHADOW;
    delete_shadow(part->shadowIndex);
}

◆ create_part_shadow_by_ref()

void create_part_shadow_by_ref	(	s32	arg0,
		ActorPart *	part )

◆ spawn_drops()

void spawn_drops ( Enemy * enemy )

Definition at line 8 of file 23680.c.

                               {
    EncounterStatus* encounter = &gCurrentEncounter;
    EnemyDrops* drops = enemy->drops;
    Npc* npc = get_npc_unsafe(enemy->npcID);
    Camera* camera = &gCameras[gCurrentCameraID];
    s32 pickupDelay;
    s32 availableRenderTasks;
    s32 availableShadows;
    s32 itemToDrop;
    f32 x, y, z;
    f32 threshold;
    f32 chance;
    f32 attempts;
    f32 fraction;
    s32 minCoinBonus;
    s32 maxCoinBonus;
    s32 spawnCounter;
    s32 dropCount;
    s32 totalWeight;
    s32 curWeight;
    s32 angle;
    s32 angleMult;
    s32 i, j;
 
    availableShadows = 0;
    for (i = 0; i < MAX_SHADOWS; i++) {
        if (get_shadow_by_index(i) == NULL) {
            availableShadows++;
        }
    }
 
    spawnCounter = 0;
    availableRenderTasks = 256 - 10 - gLastRenderTaskCount;
    angle = clamp_angle(camera->curYaw + 90.0f);
    x = npc->pos.x;
    y = npc->pos.y + (npc->collisionHeight / 2);
    z = npc->pos.z;
 
    angleMult = 0;
    pickupDelay = 0;
 
    // try dropping items
 
    dropCount = drops->itemDropChance;
    if (drops->itemDropChance > rand_int(100)) {
        totalWeight = 0;
 
        for (i = 0; i < ARRAY_COUNT(drops->itemDrops); i++) {
            if (drops->itemDrops[i].item != ITEM_NONE) {
                totalWeight += drops->itemDrops[i].weight;
            } else {
                break;
            }
        }
 
        curWeight = 0;
        dropCount = rand_int(totalWeight);
        itemToDrop = ITEM_NONE;
 
        for (i = 0; i < ARRAY_COUNT(drops->itemDrops); i++) {
            if (drops->itemDrops[i].item == ITEM_NONE) {
                break;
            }
 
            curWeight += drops->itemDrops[i].weight;
            if (drops->itemDrops[i].flagIdx > 0) {
                if (get_global_flag(EVT_INDEX_OF_GAME_FLAG(GF_SpawnedItemDrop_00) + drops->itemDrops[i].flagIdx)) {
                    continue;
                }
            }
 
            if (curWeight >= dropCount) {
                itemToDrop = drops->itemDrops[i].item;
                break;
            }
        }
 
        if (itemToDrop != ITEM_NONE) {
            make_item_entity(itemToDrop, x, y, z, ITEM_SPAWN_MODE_BATTLE_REWARD, pickupDelay, angle + angleMult * 360, 0);
            spawnCounter++;
            pickupDelay += 2;
            angle += 30.0;
            if (spawnCounter >= 12) {
                angleMult++;
                angle = angleMult * 8;
                spawnCounter = 0;
            }
 
            if (drops->itemDrops[i].flagIdx >= 0) {
                set_global_flag(EVT_INDEX_OF_GAME_FLAG(GF_SpawnedItemDrop_00) + drops->itemDrops[i].flagIdx);
            }
        }
    }
 
    if (encounter->dropWhackaBump) {
        encounter->dropWhackaBump = FALSE;
        make_item_entity(ITEM_WHACKAS_BUMP, x, y, z, ITEM_SPAWN_MODE_BATTLE_REWARD, pickupDelay, angle + angleMult * 360, 0);
        spawnCounter++;
        pickupDelay += 2;
        angle += 30.0;
        if (spawnCounter >= 12) {
            angleMult++;
            angle = angleMult * 8;
            spawnCounter = 0;
        }
    }
 
    // determine number of hearts to drop
 
    dropCount = 0;
    itemToDrop = ITEM_NONE;
    fraction = gPlayerData.curHP / (f32) gPlayerData.curMaxHP;
 
    for (i = 0; i <  ARRAY_COUNT(drops->heartDrops); i++) {
        attempts  = drops->heartDrops[i].cutoff;
        threshold = drops->heartDrops[i].generalChance;
        attempts  /= 32767.0f;
        threshold /= 32767.0f;
 
        if (fraction <= attempts && rand_int(100) <= threshold * 100.0f) {
            attempts = drops->heartDrops[i].attempts;
            chance = drops->heartDrops[i].chancePerAttempt;
            chance /= 32767.0f;
            for (j = 0; j < attempts; j++) {
                if (rand_int(100) <= chance * 100.0f) {
                    dropCount++;
                }
            }
            break;
        }
    }
 
    if (is_ability_active(ABILITY_HEART_FINDER)) {
        dropCount += 1 + rand_int(2);
    }
    if (enemy->flags & ENEMY_FLAG_NO_DROPS) {
        dropCount = 0;
    }
 
    // spawn as many of the heart drops as possible
 
    if (dropCount != 0) {
        itemToDrop = ITEM_HEART;
    }
 
    if (dropCount * 2 > availableRenderTasks) {
        dropCount = availableRenderTasks / 2;
    }
    availableRenderTasks -= 2 * dropCount;
    if (dropCount > availableShadows) {
        dropCount = availableShadows;
    }
 
    availableShadows -= dropCount;
 
    for (i = 0; i < dropCount; i++) {
        make_item_entity(itemToDrop, x, y, z, ITEM_SPAWN_MODE_BATTLE_REWARD, pickupDelay, angle + (angleMult * 360), 0);
        spawnCounter++;
        pickupDelay += 2;
        angle += 30.0;
        if (spawnCounter >= 12) {
            spawnCounter = 0;
            angleMult++;
            angle = angleMult * 8;
        }
    }
 
    // determine number of flowers to drop
 
    dropCount = 0;
    itemToDrop = ITEM_NONE;
 
    if (gPlayerData.curMaxFP > 0) {
        fraction = gPlayerData.curFP / (f32) gPlayerData.curMaxFP;
    } else {
        fraction = 0.0;
    }
 
    for (i = 0; i <  ARRAY_COUNT(drops->flowerDrops); i++) {
        attempts  = drops->flowerDrops[i].cutoff;
        threshold = drops->flowerDrops[i].generalChance;
        attempts  /= 32767.0f;
        threshold /= 32767.0f;
 
        if (fraction <= attempts && rand_int(100) <= threshold * 100.0f) {
            attempts = drops->flowerDrops[i].attempts;
            chance = drops->flowerDrops[i].chancePerAttempt;
            chance /= 32767.0f;
            for (j = 0; j < attempts; j++) {
                if (rand_int(100) <= chance * 100.0f) {
                    dropCount++;
                }
            }
            break;
        }
    }
 
    if (is_ability_active(ABILITY_FLOWER_FINDER)) {
        dropCount += 1 + rand_int(2);
    }
    if (enemy->flags & ENEMY_FLAG_NO_DROPS) {
        dropCount = 0;
    }
 
    // spawn as many of the flower drops as possible
 
    if (dropCount != 0) {
        itemToDrop = ITEM_FLOWER_POINT;
    }
 
    if (dropCount * 2 > availableRenderTasks) {
        dropCount = availableRenderTasks / 2;
    }
    availableRenderTasks -= 2 * dropCount;
    if (dropCount > availableShadows) {
        dropCount = availableShadows;
    }
 
    availableShadows -= dropCount;
 
    for (i = 0; i < dropCount; i++) {
        make_item_entity(itemToDrop, x, y, z, ITEM_SPAWN_MODE_BATTLE_REWARD, pickupDelay, angle + (angleMult * 360), 0);
        spawnCounter++;
        pickupDelay += 2;
        angle += 30.0;
        if (spawnCounter >= 12) {
            spawnCounter = 0;
            angleMult++;
            angle = angleMult * 8;
        }
    }
 
    // determine number of coins to drop
 
    itemToDrop = ITEM_COIN;
 
    //TODO maybe use an ASSERT here and forgo the odd support for reversing min/max
    if (drops->maxCoinBonus < drops->minCoinBonus) {
        // swap if max < min
        maxCoinBonus = drops->minCoinBonus;
        minCoinBonus = drops->maxCoinBonus;
    } else {
        minCoinBonus = drops->minCoinBonus;
        maxCoinBonus = drops->maxCoinBonus;
    }
 
    if (minCoinBonus < 0) {
        dropCount = rand_int(maxCoinBonus - minCoinBonus) + minCoinBonus;
    } else {
        dropCount = maxCoinBonus - minCoinBonus;
        if (dropCount != 0) {
            dropCount = rand_int(dropCount) + minCoinBonus;
        } else {
            dropCount = minCoinBonus;
        }
    }
 
    if (dropCount < 0) {
        dropCount = 0;
    }
    dropCount = dropCount + encounter->coinsEarned;
 
    if (is_ability_active(ABILITY_PAY_OFF)) {
        dropCount += encounter->damageTaken / 2;
        encounter->damageTaken = 0;
    }
    if (encounter->hasMerleeCoinBonus) {
        encounter->hasMerleeCoinBonus = FALSE;
        dropCount *= 3;
    }
    if (is_ability_active(ABILITY_MONEY_MONEY)) {
        dropCount *= 2;
    }
    if (dropCount > 20) {
        dropCount = 20;
    }
    if (enemy->flags & ENEMY_FLAG_NO_DROPS) {
        dropCount = 0;
    }
    if (dropCount * 2 > availableRenderTasks) {
        dropCount = availableRenderTasks / 2;
    }
 
    // spawn as many of the coin drops as possible
 
    availableRenderTasks -= 2 * dropCount;
 
    if (dropCount > availableShadows) {
        dropCount = availableShadows;
    }
 
    for (i = 0; i < dropCount; i++) {
        make_item_entity(itemToDrop, x, y, z, ITEM_SPAWN_MODE_BATTLE_REWARD, pickupDelay, angle + (angleMult * 360), 0);
        spawnCounter++;
        pickupDelay += 2;
        angle = angle + 30.0;
        if (spawnCounter >= 12) {
            spawnCounter = 0;
            angleMult++;
            angle = angleMult * 8;
        }
    }
}

◆ set_part_pal_adjustment()

void set_part_pal_adjustment	(	ActorPart *	part,
		s32	palAdjust )

Definition at line 2595 of file 190B20.c.

                                                             {
    if (part->idleAnimations != NULL && !(part->flags & ACTOR_PART_FLAG_NO_DECORATIONS)) {
        DecorationTable* decorations = part->decorationTable;
 
        if (decorations->paletteAdjustment != palAdjust) {
            decorations->paletteAdjustment = palAdjust;
            decorations->palAnimState = 0;
            decorations->resetPalAdjust = TRUE;
        }
    }
}

Referenced by set_actor_pal_adjustment().

◆ int_to_string()

char * int_to_string	(	s32	integer,
		char *	dest,
		s32	base )

Definition at line 385 of file 43F0.c.

                                                       {
    u8 string[40]; // Even for binary this is a little long: 34 would suffice
    s32 i = ARRAY_COUNT(string) - 2;
    s32 negative = FALSE;
    s64 longInteger = integer;
 
    // handle negative integers
    if (longInteger < 0) {
        negative = TRUE;
        longInteger *= -1;
    }
 
    // null-terminate string
    string[ARRAY_COUNT(string) - 1] = '\0';
 
    // extract digits, filling string from the back
    while (TRUE) {
        string[i] = sIntegerDigits[longInteger % base];
        longInteger /= base;
        if (longInteger == 0 || i == 0) {
            break;
        }
        i--;
    }
 
    // Add - to negatives
    if (negative) {
        i--;
        string[i] = '-';
    }
 
    // copy only populated part of string
    strcpy(dest, &string[i]);
 
    return dest;
}

Referenced by draw_number(), and set_message_int_var().

◆ get_script_by_index()

Evt * get_script_by_index ( s32 index )

Definition at line 894 of file script_list.c.

                                    {
    return (*gCurrentScriptListPtr)[index];
}

Referenced by dispatch_event_actor(), and func_802C73B8().

◆ get_script_by_id()

Evt * get_script_by_id ( s32 id )

Definition at line 898 of file script_list.c.

                              {
    s32 i;
    Evt* scriptContextPtr;
 
    for (i = 0; i < MAX_SCRIPTS; i++) {
        if ((*gCurrentScriptListPtr)[i] != NULL) {
            scriptContextPtr = (*gCurrentScriptListPtr)[i];
            if (scriptContextPtr->id == id) {
                return scriptContextPtr;
            }
        }
    }
    return 0;
}

Referenced by update_encounters_neutral().

◆ partner_test_enemy_collision()

s32 partner_test_enemy_collision ( Npc * enemy )

Definition at line 1051 of file partners.c.

                                             {
    if (wCurrentPartnerId != PARTNER_NONE && wPartner->testFirstStrike != NULL) {
        return wPartner->testFirstStrike(wPartnerNpc, enemy);
    }
    return FALSE;
}

Referenced by update_encounters_neutral().

◆ get_lava_reset_pos()

s32 get_lava_reset_pos	(	f32 *	x,
		f32 *	y,
		f32 *	z )

Definition at line 597 of file map_api.c.

                                                        {
    Vec4f *temp_v0;
    s32 temp_a0;
    LavaReset* lavaReset = gLavaResetList;
 
    if (LastSafeFloor == -1) {
        temp_v0 = &(*get_current_map_settings()->entryList)[gGameStatusPtr->entryID];
        *outX = temp_v0->x;
        *outY = temp_v0->y;
        *outZ = temp_v0->z;
        return -1;
    }
 
    while (TRUE) {
        if (lavaReset->colliderID == -1) {
            break;
        }
 
        if (lavaReset->colliderID == LastSafeFloor) {
            *outX = lavaReset->pos.x;
            *outY = lavaReset->pos.y;
            *outZ = lavaReset->pos.z;
            return 1;
        }
        lavaReset++;
    }
    return 0;
}

Referenced by action_update_hit_lava().

◆ start_rumble()

void start_rumble	(	s32	freq,
		s32	nframes )

Definition at line 15 of file rumble.c.

                                         {
    if (gGameStatusPtr->demoState == DEMO_STATE_NONE) {
        if (rumbleMaxDuration != 0) {
#if !VERSION_JP
            s32 maxFrames = rumbleMaxDuration * 2;
 
            if (nframes > maxFrames) {
                nframes = maxFrames;
            }
#endif
 
            if (nuContRmbCheck(0) == 0) {
                nuContRmbModeSet(0, 2);
                nuContRmbStart(0, freq, nframes);
            }
        }
    }
}

Referenced by action_hammer_play_hit_fx(), action_update_hit_lava(), action_update_spin_jump(), action_update_tornado_jump(), and entity_CymbalPlant_idle().

◆ update_locomotion_state()

void update_locomotion_state ( void )

Definition at line 281 of file 7E9D0.c.

                                   {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    if (!is_ability_active(ABILITY_SLOW_GO) &&
        SQ(playerStatus->stickAxis[0]) + SQ(playerStatus->stickAxis[1]) > SQ(55))
    {
        set_action_state(ACTION_STATE_RUN);
    } else {
        set_action_state(ACTION_STATE_WALK);
    }
}

Referenced by action_update_land(), action_update_step_down_land(), action_update_step_up(), and phys_player_land().

◆ start_rumble_type()

void start_rumble_type ( u32 type )

Definition at line 3098 of file 190B20.c.

                                 {
    if (bCurRumbleScript != 0) {
        kill_script_by_ID(bCurRumbleScript);
    }
 
    switch (type) {
        case BTL_RUMBLE_STOP:
            break;
        case BTL_RUMBLE_LONG:
            bCurRumbleScript = start_script(&EVS_BattleRumble_Long, EVT_PRIORITY_A, EVT_FLAG_RUN_IMMEDIATELY)->id;
            break;
        case BTL_RUMBLE_HIT_MIN:
            bCurRumbleScript = start_script(&EVS_BattleRumble_HitMin, EVT_PRIORITY_A, EVT_FLAG_RUN_IMMEDIATELY)->id;
            break;
        case BTL_RUMBLE_HIT_LIGHT:
            bCurRumbleScript = start_script(&EVS_BattleRumble_HitLight, EVT_PRIORITY_A, EVT_FLAG_RUN_IMMEDIATELY)->id;
            break;
        case BTL_RUMBLE_HIT_HEAVY:
            bCurRumbleScript = start_script(&EVS_BattleRumble_HitHeavy, EVT_PRIORITY_A, EVT_FLAG_RUN_IMMEDIATELY)->id;
            break;
        case BTL_RUMBLE_HIT_EXTREME:
            bCurRumbleScript = start_script(&EVS_BattleRumble_HitExtreme, EVT_PRIORITY_A, EVT_FLAG_RUN_IMMEDIATELY)->id;
            break;
        case BTL_RUMBLE_HIT_MAX:
            bCurRumbleScript = start_script(&EVS_BattleRumble_HitMax, EVT_PRIORITY_A, EVT_FLAG_RUN_IMMEDIATELY)->id;
            break;
        case BTL_RUMBLE_PLAYER_MIN:
        case BTL_RUMBLE_PLAYER_LIGHT:
        case BTL_RUMBLE_PLAYER_HEAVY:
        case BTL_RUMBLE_PLAYER_EXTREME:
        case BTL_RUMBLE_PLAYER_MAX:
            bCurRumbleScript = start_script(&EVS_BattleRumble_PlayerMin, EVT_PRIORITY_A, EVT_FLAG_RUN_IMMEDIATELY)->id;
            break;
    }
}

◆ start_falling()

void start_falling ( void )

Definition at line 293 of file 7E9D0.c.

                         {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    set_action_state(ACTION_STATE_FALLING);
    LOAD_INTEGRATOR_FALL(playerStatus->gravityIntegrator);
}

Referenced by action_update_use_spinning_flower().

◆ start_bounce_a()

void start_bounce_a ( void )

Definition at line 300 of file 7E9D0.c.

                          {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    set_action_state(ACTION_STATE_BOUNCE);
    playerStatus->gravityIntegrator[0] = 10.0f;
    playerStatus->gravityIntegrator[1] = -2.0f;
    playerStatus->gravityIntegrator[2] = 0.8f;
    playerStatus->gravityIntegrator[3] = -0.75f;
}

Referenced by update_encounters_neutral().

◆ start_bounce_b()

void start_bounce_b ( void )

Definition at line 310 of file 7E9D0.c.

                          {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    set_action_state(ACTION_STATE_BOUNCE);
    playerStatus->gravityIntegrator[0] = 8.0f;
    playerStatus->gravityIntegrator[1] = -1.0f;
    playerStatus->gravityIntegrator[2] = 0;
    playerStatus->gravityIntegrator[3] = 0;
    playerStatus->flags |= PS_FLAG_SCRIPTED_FALL;
}

◆ update_input()

void update_input ( void )

Definition at line 31 of file input.c.

                        {
    OSContPad* contData = &D_8009A5B8;
    s16 handleInput = FALSE;
    s16 cond1;
    s32 buttons;
    s16 stickX;
    s16 stickY;
 
    if (gGameStatusPtr->contBitPattern & 1) {
        handleInput = TRUE;
        nuContDataGet(contData, 0);
    }
 
    if (gGameStatusPtr->demoState != DEMO_STATE_NONE) {
        if (gGameStatusPtr->demoState < DEMO_STATE_CHANGE_MAP
            && (contData->button & (BUTTON_A | BUTTON_B | BUTTON_Z | BUTTON_START))
            && handleInput
        ) {
            gGameStatusPtr->demoState = DEMO_STATE_CHANGE_MAP;
        }
        contData->button = gGameStatusPtr->demoButtonInput;
        contData->stick_x = gGameStatusPtr->demoStickX;
        contData->stick_y = gGameStatusPtr->demoStickY;
        handleInput = TRUE;
    }
 
    if (!handleInput) {
        return;
    }
 
    stickX = contData->stick_x;
    stickY = contData->stick_y;
    if (stickX > 0) {
        stickX -= 4;
        if (stickX < 0) {
            stickX = 0;
        }
    }
    if (stickX < 0) {
        stickX += 4;
        if (stickX > 0) {
            stickX = 0;
        }
    }
 
    if (stickY > 0) {
        stickY -= 4;
        if (stickY < 0) {
            stickY = 0;
        }
    }
    if (stickY < 0) {
        stickY += 4;
        if (stickY > 0) {
            stickY = 0;
        }
    }
 
    gGameStatusPtr->stickX[0] = stickX;
    gGameStatusPtr->stickY[0] = stickY;
 
    buttons = contData->button;
    cond1 = FALSE;
    if (stickX > 0x20) {
        cond1 = TRUE;
        buttons |= BUTTON_STICK_RIGHT;
        if (!(gGameStatusPtr->prevButtons[0] & BUTTON_STICK_RIGHT)) {
            D_8009A6A0 = stickX;
        } else if (D_8009A6A4 == 0) {
            if (D_8009A6A0 < stickX) {
                D_8009A6A0 = stickX;
            }
        } else {
            if (D_8009A6A0 > stickX) {
                D_8009A6A0 = stickX;
            }
        }
    }
 
    if (stickX < -0x20) {
        cond1 = TRUE;
        buttons |= BUTTON_STICK_LEFT;
        if (!(gGameStatusPtr->prevButtons[0] & BUTTON_STICK_LEFT)) {
            D_8009A6A0 = stickX;
        } else if (D_8009A6A4 == 0) {
            if (D_8009A6A0 > stickX) {
                D_8009A6A0 = stickX;
            }
        } else {
            if (D_8009A6A0 < stickX)
            {
                D_8009A6A0 = stickX;
            }
        }
    }
 
    if (!cond1) {
        D_8009A6A4 = 0;
        D_8009A6A0 = stickX;
    }
 
    cond1 = FALSE;
    if (stickY > 0x20) {
        cond1 = TRUE;
        buttons |= BUTTON_STICK_UP;
        if (!(gGameStatusPtr->prevButtons[0] & BUTTON_STICK_UP)) {
            D_8009A6A2 = stickY;
        } else if (D_8009A6A6 == 0) {
            if (D_8009A6A2 < stickY) {
                D_8009A6A2 = stickY;
            }
        } else {
            if (D_8009A6A2 > stickY) {
                D_8009A6A2 = stickY;
            }
        }
    }
 
    if (stickY < -0x20) {
        cond1 = TRUE;
        buttons |= BUTTON_STICK_DOWN;
        if (!(gGameStatusPtr->prevButtons[0] & BUTTON_STICK_DOWN)) {
            D_8009A6A2 = stickY;
        } else if (D_8009A6A6 == 0) {
            if (D_8009A6A2 > stickY) {
                D_8009A6A2 = stickY;
            }
        } else {
            if (D_8009A6A2 < stickY) {
                D_8009A6A2 = stickY;
            }
        }
    }
 
    if (!cond1) {
        D_8009A6A6 = 0;
        D_8009A6A2 = stickY;
    }
 
    if (stickX > 0x20) {
        if (D_8009A6A4 == 1 && stickX - D_8009A6A0 > 0x10) {
            buttons &= ~BUTTON_STICK_RIGHT;
            D_8009A6A4 = 0;
        }
        if (D_8009A6A0 - stickX > 0x10) {
            D_8009A6A4 = 1;
        }
    }
 
    if (stickX < -0x20) {
        if (D_8009A6A4 == 1 && D_8009A6A0 - stickX > 0x10) {
            buttons &= ~BUTTON_STICK_LEFT;
            D_8009A6A4 = 0;
        }
        if (stickX - D_8009A6A0 > 0x10) {
            D_8009A6A4 = 1;
        }
    }
 
    if (stickY > 0x20) {
        if (D_8009A6A6 == 1 && stickY - D_8009A6A2 > 0x10) {
            buttons &= ~BUTTON_STICK_UP;
            D_8009A6A6 = 0;
        }
        if (D_8009A6A2 - stickY > 0x10) {
            D_8009A6A6 = 1;
        }
    }
 
    if (stickY < -0x20) {
        if (D_8009A6A6 == 1 && D_8009A6A2 - stickY > 0x10) {
            buttons &= ~BUTTON_STICK_DOWN;
            D_8009A6A6 = 0;
        }
        if (stickY - D_8009A6A2 > 0x10) {
            D_8009A6A6 = 1;
        }
    }
 
    gGameStatusPtr->curButtons[0] = buttons;
    gGameStatusPtr->pressedButtons[0] = gGameStatusPtr->curButtons[0] ^ gGameStatusPtr->prevButtons[0];
    gGameStatusPtr->pressedButtons[0] &= gGameStatusPtr->curButtons[0];
 
    if (gGameStatusPtr->curButtons[0] == 0) {
        gGameStatusPtr->heldButtons[0] = 0;
    } else if (gGameStatusPtr->prevButtons[0] != gGameStatusPtr->curButtons[0]) {
        gGameStatusPtr->heldButtons[0] = gGameStatusPtr->curButtons[0];
        gGameStatusPtr->unk_60 = -1;
        gGameStatusPtr->heldButtons[0] = gGameStatusPtr->curButtons[0] ^ gGameStatusPtr->prevButtons[0];
        gGameStatusPtr->heldButtons[0] &= gGameStatusPtr->curButtons[0];
        gGameStatusPtr->unk_58 = gGameStatusPtr->unk_48[0];
    } else {
        if (gGameStatusPtr->unk_60 >= 0) {
            gGameStatusPtr->unk_60--;
            if (gGameStatusPtr->unk_60 != 0) {
                gGameStatusPtr->heldButtons[0] = 0;
            } else {
                gGameStatusPtr->heldButtons[0] = gGameStatusPtr->curButtons[0];
                gGameStatusPtr->unk_60 = gGameStatusPtr->unk_50[0];
            }
        } else {
            gGameStatusPtr->unk_58--;
            if (gGameStatusPtr->unk_58 != 0) {
                gGameStatusPtr->heldButtons[0] = 0;
            } else {
                gGameStatusPtr->heldButtons[0] = gGameStatusPtr->curButtons[0];
                gGameStatusPtr->unk_60 = gGameStatusPtr->unk_50[0];
            }
        }
    }
 
    gGameStatusPtr->prevButtons[0] = gGameStatusPtr->curButtons[0];
}

Referenced by step_game_loop().

◆ update_max_rumble_duration()

void update_max_rumble_duration ( void )

Definition at line 34 of file rumble.c.

                                      {
    if (rumbleButtons != gGameStatusPtr->curButtons[0]) {
        rumbleButtons = gGameStatusPtr->curButtons[0];
        reset_max_rumble_duration();
    }
 
    if (rumbleMaxDuration != 0) {
        rumbleMaxDuration--;
    }
}

Referenced by step_game_loop().

◆ mdl_reset_transform_flags()

void mdl_reset_transform_flags ( void )

Definition at line 3755 of file model.c.

                                     {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentModels); i++) {
        Model* model = (*gCurrentModels)[i];
 
        if (model != NULL) {
            model->flags &= ~MODEL_FLAG_HAS_TRANSFORM;
        }
    }
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentTransformGroups); i++) {
        ModelTransformGroup* transformGroup = (*gCurrentTransformGroups)[i];
 
        if (transformGroup != NULL) {
            transformGroup->flags &= ~TRANSFORM_GROUP_FLAG_HAS_TRANSFORM;
        }
    }
}

Referenced by step_game_loop().

◆ update_workers()

void update_workers ( void )

Definition at line 125 of file worker.c.

                          {
    s32 i;
 
    for (i = 0; i < MAX_WORKERS; i++) {
        Worker* worker = (*gCurrentWorkerListPtr)[i];
        if (worker != NULL) {
            worker->flags &= ~WORKER_FLAG_SKIP_DRAW_UNTIL_UPDATE;
            worker->update();
        }
    }
}

Referenced by step_game_loop().

◆ update_triggers()

void update_triggers ( void )

Definition at line 89 of file trigger.c.

                           {
    CollisionStatus* collisionStatus = &gCollisionStatus;
    Trigger* listTrigger;
    s32 i;
 
    collisionStatus->touchingWallTrigger = 0;
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentTriggerListPtr); i++) {
        listTrigger = (*gCurrentTriggerListPtr)[i];
 
        if (listTrigger == NULL) {
            continue;
        }
 
        if (!(listTrigger->flags & TRIGGER_ACTIVE)) {
            continue;
        }
 
        if (listTrigger->flags & TRIGGER_FORCE_ACTIVATE) {
            listTrigger->flags |= TRIGGER_ACTIVATED;
            continue;
        }
 
        if (listTrigger->flags & TRIGGER_WALL_PUSH) {
            if (listTrigger->location.colliderID == collisionStatus->curWall) {
                func_800E06C0(1);
            }
            if (listTrigger->location.colliderID == collisionStatus->pushingAgainstWall) {
                func_800E06C0(0);
            } else {
                continue;
            }
        }
 
        if (listTrigger->flags & TRIGGER_FLOOR_TOUCH) {
            if (listTrigger->location.colliderID != collisionStatus->curFloor) {
                continue;
            }
        }
 
        if (listTrigger->flags & TRIGGER_FLOOR_ABOVE) {
            if (listTrigger->location.colliderID != collisionStatus->floorBelow) {
                continue;
            }
        }
 
        if (listTrigger->flags & TRIGGER_WALL_PRESS_A) {
            if (listTrigger->location.colliderID == collisionStatus->curWall) {
                collisionStatus->touchingWallTrigger = 1;
            }
            if ((listTrigger->location.colliderID != collisionStatus->curInspect) || !phys_can_player_interact()) {
                continue;
            }
        }
 
        if (listTrigger->flags & TRIGGER_WALL_TOUCH) {
            if (listTrigger->location.colliderID != collisionStatus->curWall) {
                continue;
            }
        }
 
        if (listTrigger->flags & TRIGGER_FLOOR_JUMP) {
            if (listTrigger->location.colliderID != collisionStatus->lastTouchedFloor) {
                continue;
            }
        }
 
        if (listTrigger->flags & TRIGGER_FLOOR_PRESS_A) {
            if ((listTrigger->location.colliderID != collisionStatus->curFloor) ||
                !(gGameStatusPtr->pressedButtons[0] & BUTTON_A) || (gPlayerStatus.flags & PS_FLAG_INPUT_DISABLED)) {
                continue;
            }
        }
 
        if (listTrigger->flags & TRIGGER_WALL_HAMMER) {
            if (listTrigger->location.colliderID != collisionStatus->lastWallHammered) {
                continue;
            }
        }
 
        if (listTrigger->flags & TRIGGER_CEILING_TOUCH) {
            if (listTrigger->location.colliderID != collisionStatus->curCeiling) {
                continue;
            }
        }
 
        if (listTrigger->flags & TRIGGER_FLAG_2000) {
            if (listTrigger->location.colliderID != collisionStatus->unk_0C) {
                continue;
            }
        }
 
        if (listTrigger->flags & TRIGGER_FLAG_4000) {
            if (listTrigger->location.colliderID != collisionStatus->unk_0E) {
                continue;
            }
        }
 
        if (listTrigger->flags & TRIGGER_FLAG_8000) {
            if (listTrigger->location.colliderID != collisionStatus->unk_10) {
                continue;
            }
        }
 
        if (listTrigger->flags & TRIGGER_POINT_BOMB) {
            BombTrigger* bombPos;
            f32 dist;
 
            if (collisionStatus->bombetteExploded < 0) {
                continue;
            }
 
            bombPos = listTrigger->location.blast;
            dist = dist3D(bombPos->pos.x, bombPos->pos.y, bombPos->pos.z,
                                collisionStatus->bombetteExplosionPos.x, collisionStatus->bombetteExplosionPos.y,
                                collisionStatus->bombetteExplosionPos.z);
 
            if ((bombPos->diameter * 0.5f) + 50.0f < dist) {
                continue;
            }
        }
 
        if (listTrigger->flags & TRIGGER_GAME_FLAG_SET && get_global_flag(listTrigger->varIndex) == 0) {
            continue;
        }
 
        if (listTrigger->flags & TRIGGER_AREA_FLAG_SET && get_area_flag(listTrigger->varIndex) == 0) {
            continue;
        }
 
        listTrigger->flags |= TRIGGER_ACTIVATED;
    }
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentTriggerListPtr); i++) {
        listTrigger = (*gCurrentTriggerListPtr)[i];
 
        if (listTrigger == NULL) {
            continue;
        }
 
        if (listTrigger->flags & TRIGGER_ACTIVE) {
            if (listTrigger->flags & TRIGGER_ACTIVATED) {
                if (listTrigger->onActivateFunc(listTrigger) == 0) {
                    listTrigger->flags &= ~TRIGGER_ACTIVATED;
                }
            }
        }
    }
}

Referenced by step_game_loop().

◆ update_scripts()

void update_scripts ( void )

Definition at line 550 of file script_list.c.

                          {
    s32 i;
 
    if (gGameStatusPtr->debugScripts == DEBUG_SCRIPTS_NO_UPDATE) {
        return;
    }
 
    IsUpdatingScripts = TRUE;
    sort_scripts();
 
    for (i = 0; i < gScriptListCount; i++) {
        Evt* script = (*gCurrentScriptListPtr)[gScriptIndexList[i]];
 
        if (script != NULL &&
            script->id == gScriptIdList[i] &&
            script->stateFlags != 0 &&
            !(script->stateFlags & (EVT_FLAG_SUSPENDED | EVT_FLAG_BLOCKED_BY_CHILD | EVT_FLAG_PAUSED)))
        {
            s32 stop = FALSE;
            s32 status;
 
            script->frameCounter += script->timeScale;
 
            do {
                if (script->frameCounter < 1.0) {
                    // Continue to next script
                    break;
                };
 
                script->frameCounter -= 1.0;
                status = evt_execute_next_command(script);
                if (status == EVT_CMD_RESULT_ERROR) {
                    stop = TRUE;
                    break;
                }
            } while (status != EVT_CMD_RESULT_YIELD);
 
            if (stop) {
                break;
            }
        }
    }
    IsUpdatingScripts = FALSE;
}

Referenced by step_game_loop().

◆ update_messages()

void update_messages ( void )

Definition at line 247 of file msg.c.

                           {
    s32 i;
 
    gMsgGlobalWaveCounter++;
    if (gMsgGlobalWaveCounter >= 360) {
        gMsgGlobalWaveCounter = 0;
    }
 
    for (i = 0; i < ARRAY_COUNT(gMessagePrinters); i++) {
        if (gMessagePrinters[i].stateFlags & MSG_STATE_FLAG_2) {
            _update_message(&gMessagePrinters[i]);
        }
    }
 
    gMsgBGScrollAmtX += 12;
    gMsgBGScrollAmtY -= 12;
    if (gMsgBGScrollAmtX >= 2048) {
        gMsgBGScrollAmtX -= 2048;
    }
    if (gMsgBGScrollAmtY < 0) {
        gMsgBGScrollAmtY += 2048;
    }
}

Referenced by step_game_loop().

◆ update_entities()

void update_entities ( void )

Definition at line 82 of file entity.c.

                           {
    s32 i;
 
    D_801512BC = 0;
    entity_numEntities = 0;
    entity_updateCounter++;
 
    for (i = 0; i < MAX_ENTITIES; i++) {
        Entity* entity = get_entity_by_index(i);
 
        if (entity != NULL) {
            entity_numEntities++;
 
            if (!(entity->flags & ENTITY_FLAG_SKIP_UPDATE)) {
                if (entity->flags & ENTITY_FLAG_BOUND_SCRIPT_DIRTY) {
                    entity->flags &= ~ENTITY_FLAG_BOUND_SCRIPT_DIRTY;
                    if (!(entity->flags & ENTITY_FLAG_8000)) {
                        entity->flags |= ENTITY_FLAG_2000000;
                    }
                    entity->boundScript = start_script(entity->boundScriptBytecode, EVT_PRIORITY_A, EVT_FLAG_RUN_IMMEDIATELY);
                }
 
                if (entity->flags & ENTITY_FLAG_2000000) {
                    if (does_script_exist(entity->boundScript->id)) {
                        if (entity->flags & ENTITY_FLAG_HAS_ANIMATED_MODEL) {
                            update_model_animator(entity->virtualModelIndex);
                        } else {
                            exec_entity_model_commandlist(entity->virtualModelIndex);
                        }
 
                        if (entity->flags & ENTITY_FLAG_ALWAYS_FACE_CAMERA) {
                            entity->rot.y = -gCameras[gCurrentCameraID].curYaw;
                        }
 
                        if (!(entity->flags & ENTITY_FLAG_SKIP_UPDATE_TRANSFORM_MATRIX)) {
                            update_entity_transform_matrix(entity);
                        }
                        continue;
                    } else {
                        entity->flags &= ~ENTITY_FLAG_2000000;
                    }
                }
 
                if (entity->collisionTimer == 0) {
                    entity->collisionFlags = entity_get_collision_flags(entity);
 
                    if (entity->collisionFlags) {
                        EntityCallback handleCollision = entity->blueprint->fpHandleCollision;
 
                        if (handleCollision != NULL && handleCollision(entity) != 0) {
                            entity->collisionTimer = 10;
                            entity->flags |= ENTITY_FLAG_DETECTED_COLLISION;
                        }
                    }
                } else {
                    entity->collisionTimer--;
                    if (entity->flags & ENTITY_FLAG_CONTINUOUS_COLLISION) {
                        if (entity->collisionTimer == 0) {
                            entity->flags &= ~(ENTITY_FLAG_DISABLE_COLLISION | ENTITY_FLAG_CONTINUOUS_COLLISION);
                        } else {
                            entity->flags |= ENTITY_FLAG_DISABLE_COLLISION;
                        }
                    } else if (entity->collisionTimer == 0) {
                        entity->flags &= ~ENTITY_FLAG_DETECTED_COLLISION;
                        entity->flags &= ~ENTITY_FLAG_PARTNER_COLLISION;
                        entity->collisionFlags = 0;
                    }
                }
 
                if (entity->flags & ENTITY_FLAG_ALWAYS_FACE_CAMERA) {
                    entity->rot.y = -gCameras[gCurrentCameraID].curYaw;
                }
 
                if (gGameStatusPtr->debugScripts == DEBUG_SCRIPTS_NONE) {
                    if (entity->updateScriptCallback != NULL) {
                        entity->updateScriptCallback(entity);
                    }
 
                    if (entity->scriptReadPos != NULL) {
                        if (entity->scriptDelay != 0) {
                            entity->scriptDelay--;
                            if (entity->scriptDelay == 0) {
                                while (step_entity_commandlist(entity));
                            }
                        }
                    }
                }
 
                if (!(entity->flags & ENTITY_FLAG_SKIP_UPDATE_TRANSFORM_MATRIX)) {
                    update_entity_transform_matrix(entity);
                }
 
                if (!(entity->flags & ENTITY_FLAG_DISABLE_COLLISION)) {
                    update_entity_inverse_rotation_matrix(entity);
                }
 
                if (entity->flags & ENTITY_FLAG_HAS_ANIMATED_MODEL) {
                    update_model_animator(entity->virtualModelIndex);
                } else {
                    exec_entity_model_commandlist(entity->virtualModelIndex);
                }
 
                if (entity->shadowIndex >= 0) {
                    update_entity_shadow_position(entity);
                }
 
                if (entity->flags & ENTITY_FLAG_PENDING_INSTANCE_DELETE) {
                    delete_entity(entity->listIndex);
                }
 
                if (entity->flags & ENTITY_FLAG_PENDING_FULL_DELETE) {
                    delete_entity_and_unload_data(entity->listIndex);
                }
            }
        }
    }
 
    update_shadows();
    gCurrentHiddenPanels.tryFlipTrigger = FALSE;
}

Referenced by step_game_loop().

◆ func_80138198()

void func_80138198 ( void )

Definition at line 473 of file screen_overlays.c.

473 {

474}

Referenced by step_game_loop().

◆ bgm_update_music_settings()

void bgm_update_music_settings ( void )

Definition at line 82 of file e0b30_len_b80.c.

                                     {
    MusicSettings* music = gMusicSettings;
    s32 i = 0;
    s16 state2 = 2;
    s16 flag4 = MUSIC_SETTINGS_FLAG_4;
    s32 flags;
 
    for (i; i < ARRAY_COUNT(gMusicSettings); i++, music++) {
        switch (music->state) {
        case 0:
            break;
        case 1:
            if (music->flags & MUSIC_SETTINGS_FLAG_1) {
                if (music->fadeOutTime < 250) {
                    if (!(music->flags & MUSIC_SETTINGS_FLAG_4)) {
                        if (au_song_stop(music->songName) == AU_RESULT_OK) {
                            music->state = state2;
                        }
                    } else {
                        if (func_80055AF0(music->songName) == AU_RESULT_OK) {
                           music->state = state2;
                        }
                    }
                } else if (!(music->flags & MUSIC_SETTINGS_FLAG_4)) {
                    if (snd_set_song_variation_fade_time(music->songName, music->fadeOutTime, 0) == 0) {
                        music->state = state2;
                    }
                } else {
                    if (func_80055BB8(music->songName, 250) == AU_RESULT_OK) {
                        music->state = state2;
                    }
                }
            } else {
                if (music->flags & MUSIC_SETTINGS_FLAG_4) {
                    music->flags |= MUSIC_SETTINGS_FLAG_10;
                }
                music->flags &= ~flag4;
                music->state = 5;
            }
            break;
        case 2:
            flags = music->flags;
            music->flags &= ~flag4;
            if (flags & MUSIC_SETTINGS_FLAG_1) {
                if (au_song_is_playing(music->songName) == AU_RESULT_OK) {
                    music->flags &= ~MUSIC_SETTINGS_FLAG_1;
                    music->state = 3;
                }
            } else {
                music->state = 5;
            }
            break;
        case 3:
            music->state = 4;
            break;
        case 4:
            music->state = 5;
            break;
        case 5:
            if (!(music->flags & MUSIC_SETTINGS_FLAG_8)) {
                if (music->songID < 0) {
                    music->state = 0;
                } else {
                    music->songName = au_song_load(music->songID, i);
                    if (music->songName > 0xFFFFU) {
                        if ((music->flags & MUSIC_SETTINGS_FLAG_20)) {
                            snd_set_song_variation_fade(music->songName, music->variation,
                                music->fadeInTime, music->fadeStartVolume, music->fadeEndVolume);
                            music->flags &= ~MUSIC_SETTINGS_FLAG_20;
                        } else {
                            bgm_set_target_volume(MusicDefaultVolume);
                        }
                        if (au_song_start_variation(music->songName, music->variation) == 0) {
                            music->flags |= MUSIC_SETTINGS_FLAG_1;
                            music->state = 0;
                        }
                    }
                }
            } else {
                if (music->flags & MUSIC_SETTINGS_FLAG_10) {
                    music->state = 0;
                    music->flags &= ~(MUSIC_SETTINGS_FLAG_10 | MUSIC_SETTINGS_FLAG_8);
                } else if (func_80055B28(music->savedSongName) == 0) {
                    music->songID = music->savedSongID;
                    music->variation = music->savedVariation;
                    music->songName = music->savedSongName;
                    music->state = 0;
                    music->flags |= MUSIC_SETTINGS_FLAG_1;
                    music->flags &= ~MUSIC_SETTINGS_FLAG_8;
                }
            }
            break;
        }
    }
    bgm_update_volume();
}

Referenced by step_game_loop().

◆ func_8014AD40()

s32 func_8014AD40 ( void )

Definition at line 359 of file e0b30_len_b80.c.

                        {
    MusicSettings* settings = gMusicSettings;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gMusicSettings); i++, settings++) {
        if (!(settings->flags & MUSIC_SETTINGS_FLAG_1)) {
            continue;
        }
 
        if (au_song_is_playing(settings->songName)) {
            return TRUE;
        }
    }
    return FALSE;
}

◆ update_ambient_sounds()

void update_ambient_sounds ( void )

Definition at line 32 of file ambience.c.

                                 {
    AmbientSoundSettings* ambientSoundState = &AmbientSoundData;
    s32 error;
 
    switch (ambientSoundState->fadeState) {
        case AMBIENT_SOUND_IDLE:
            break;
        case AMBIENT_SOUND_FADE_OUT:
            if (ambientSoundState->flags & 1) {
                if (ambientSoundState->fadeTime < 250) {
                    error = snd_ambient_stop_quick(0);
                } else {
                    error = snd_ambient_stop_slow(0, ambientSoundState->fadeTime);
                }
 
                if (error != AU_RESULT_OK) {
                    return;
                }
            }
            ambientSoundState->fadeState = AMBIENT_SOUND_FADE_IN;
            break;
        case AMBIENT_SOUND_FADE_IN:
            if (ambientSoundState->flags & 1) {
                if (snd_ambient_is_stopped(0) != AU_RESULT_OK) {
                    return;
                }
                ambientSoundState->flags &= ~1;
            }
            if (ambientSoundState->soundID < 0) {
                ambientSoundState->fadeState = AMBIENT_SOUND_IDLE;
            } else if (snd_load_ambient(ambientSoundState->soundID) == AU_RESULT_OK) {
                if (snd_ambient_play(0, 0) == AU_RESULT_OK) {
                    ambientSoundState->fadeState = AMBIENT_SOUND_IDLE;
                    ambientSoundState->flags |= 1;
                }
            }
            break;
    }
}

Referenced by step_game_loop().

◆ update_windows()

void update_windows ( void )

Definition at line 143 of file windows.c.

                          {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gWindows); i++) {
        u8 flags = gWindows[i].flags;
 
        if (!flags || (flags & WINDOW_FLAG_DISABLED)) {
            continue;
        }
 
        if (flags & WINDOW_FLAG_FPUPDATE_CHANGED) {
            gWindows[i].flags = flags & ~WINDOW_FLAG_FPUPDATE_CHANGED;
            gWindows[i].fpUpdate = gWindows[i].fpPending;
            gWindows[i].updateCounter = 0;
        }
    }
}

Referenced by step_game_loop().

◆ player_render_interact_prompts()

void player_render_interact_prompts ( void )

Definition at line 1028 of file 77480.c.

                                          {
    render_conversation_prompt();
    render_interact_prompt();
    render_pulse_stone_icon();
    render_ispy_icon();
}

Referenced by gfx_draw_frame().

◆ func_802C3EE4()

void func_802C3EE4 ( void )

Definition at line 596 of file script_list.c.

                         {
    s32 temp;
    s32 i;
 
    for (i = 0; i < gScriptListCount; i++) {
        temp = (s32) (*gCurrentScriptListPtr)[gScriptIndexList[i]];
        temp = *((s32*) temp);
        if (temp == gScriptIdList[i]) {
            temp = 1;
        }
    }
}

Referenced by gfx_draw_frame().

◆ render_screen_overlay_backUI()

void render_screen_overlay_backUI ( void )

Definition at line 485 of file screen_overlays.c.

                                        {
    if (screen_overlay_backType != OVERLAY_NONE
        && screen_overlay_backZoom != -1.0f
        && gGameStatusPtr->context != CONTEXT_PAUSE
    ) {
        _render_transition_stencil(screen_overlay_backType, screen_overlay_backZoom, &ScreenOverlays[1]);
    }
}

Referenced by gfx_draw_frame().

◆ render_workers_backUI()

void render_workers_backUI ( void )

Definition at line 163 of file worker.c.

                                 {
    s32 i;
 
    for (i = 0; i < MAX_WORKERS; i++) {
        Worker* worker = (*gCurrentWorkerListPtr)[i];
        if (worker != NULL && !(worker->flags & WORKER_FLAG_SKIP_DRAW_UNTIL_UPDATE)) {
            if (worker->flags & WORKER_FLAG_BACK_UI) {
                worker->draw();
            }
        }
    }
}

Referenced by gfx_draw_frame().

◆ render_effects_UI()

void render_effects_UI ( void )

Definition at line 140 of file effects.c.

                             {
    s32 cond = TRUE;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gEffectInstances); i++) {
        EffectInstance* effectInstance = gEffectInstances[i];
 
        if (effectInstance != NULL) {
            if (effectInstance->flags & FX_INSTANCE_FLAG_ENABLED) {
                if (effectInstance->flags & FX_INSTANCE_FLAG_HAS_UPDATED) {
                    void (*renderUI)(EffectInstance* effect);
 
                    if (gGameStatusPtr->context != CONTEXT_WORLD && !(effectInstance->flags & FX_INSTANCE_FLAG_BATTLE)) {
                        continue;
                    }
 
                    if (gGameStatusPtr->context == CONTEXT_WORLD && effectInstance->flags & FX_INSTANCE_FLAG_BATTLE) {
                        continue;
                    }
 
                    renderUI = effectInstance->shared->renderUI;
                    if (renderUI != stub_effect_delegate) {
                        if (cond) {
                            Camera* camera = &gCameras[gCurrentCameraID];
 
                            gDPPipeSync(gMainGfxPos++);
                            gSPViewport(gMainGfxPos++, &camera->vp);
                            gSPClearGeometryMode(gMainGfxPos++, G_ZBUFFER | G_SHADE | G_CULL_BOTH | G_FOG |
                                                G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD |
                                                G_SHADING_SMOOTH | G_CLIPPING | 0x40F9FA);
                            gSPSetGeometryMode(gMainGfxPos++, G_ZBUFFER | G_SHADE | G_CULL_BACK | G_SHADING_SMOOTH);
                            gDPSetScissor(gMainGfxPos++, G_SC_NON_INTERLACE,
                                              camera->viewportStartX,
                                              camera->viewportStartY,
                                              camera->viewportStartX + camera->viewportW,
                                              camera->viewportStartY + camera->viewportH);
                            gSPClipRatio(gMainGfxPos++, FRUSTRATIO_2);
 
                            cond = FALSE;
                            if (!(camera->flags & CAMERA_FLAG_ORTHO)) {
                                gSPPerspNormalize(gMainGfxPos++, camera->perspNorm);
                                gSPMatrix(gMainGfxPos++, &gDisplayContext->camPerspMatrix[gCurrentCameraID],
                                          G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
                            }
                        }
 
                        renderUI(effectInstance);
                    }
                }
            }
        }
    }
}

Referenced by gfx_draw_frame().

◆ render_window_root()

void render_window_root ( void )

Definition at line 347 of file windows.c.

                              {
    s32 priorityArray[ARRAY_COUNT(gWindows)];
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gWindows); i++) {
        priorityArray[i] = WIN_NONE;
    }
 
    for (i = 0; i < ARRAY_COUNT(gWindows); i++) {
        if (gWindows[i].flags != 0) {
            priorityArray[gWindows[i].priority] = i;
        }
    }
 
    gSPLoadGeometryMode(gMainGfxPos++, 0);
    gSPSetGeometryMode(gMainGfxPos++, G_ZBUFFER | G_SHADE | G_CULL_BOTH | G_SHADING_SMOOTH);
    gDPPipelineMode(gMainGfxPos++, G_PM_NPRIMITIVE);
    gDPSetCombineMode(gMainGfxPos++, G_CC_SHADE, G_CC_SHADE);
    gDPSetAlphaCompare(gMainGfxPos++, G_AC_NONE);
    gSPSetOtherMode(gMainGfxPos++, G_SETOTHERMODE_H, G_MDSFT_ALPHADITHER, 16, G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE | G_TD_CLAMP | G_TP_NONE);
    gSPClipRatio(gMainGfxPos++, FRUSTRATIO_2);
    gDPSetColorImage(gMainGfxPos++, G_IM_FMT_RGBA, G_IM_SIZ_16b, SCREEN_WIDTH, osVirtualToPhysical(nuGfxCfb_ptr));
    gDPPipeSync(gMainGfxPos++);
    render_windows(priorityArray, WIN_NONE, 0, 0, 0, 255, 0, NULL);
}

Referenced by gfx_draw_frame().

◆ render_messages()

void render_messages ( void )

Definition at line 568 of file msg.c.

                           {
    Mtx* matrix = &gMessageWindowProjMatrix[gCurrentDisplayContextIndex];
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gMessagePrinters); i++) {
        if (gMessagePrinters[i].stateFlags & MSG_STATE_FLAG_2) {
            gSPViewport(gMainGfxPos++, &D_8014C280);
            guOrtho(matrix, 0.0f, 319.0f, -240.0f, 0.0f, -500.0f, 500.0f, 1.0f);
            gSPMatrix(gMainGfxPos++, OS_K0_TO_PHYSICAL(matrix), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
            gDPPipeSync(gMainGfxPos++);
            gDPSetCycleType(gMainGfxPos++, G_CYC_1CYCLE);
            gSPClearGeometryMode(gMainGfxPos++, G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN |
                                 G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH);
            gSPSetGeometryMode(gMainGfxPos++, G_SHADE | G_SHADING_SMOOTH);
            break;
        }
    }
 
    for (i = 0; i < ARRAY_COUNT(gMessagePrinters); i++) {
        if (gMessagePrinters[i].stateFlags & MSG_STATE_FLAG_2) {
            draw_message_window(&gMessagePrinters[i]);
 
            if (gMessagePrinters[i].windowState == MSG_WINDOW_STATE_WAITING) {
                if (!(gMessagePrinters[i].stateFlags & MSG_STATE_FLAG_8000) &&
                    !(gMessagePrinters[i].stateFlags & MSG_STATE_FLAG_40))
                {
                    msg_update_rewind_arrow(i);
                }
            } else if (gMessagePrinters[i].windowState == MSG_WINDOW_STATE_C) {
                msg_draw_rewind_arrow(i);
            } else if (gMessagePrinters[i].windowState == MSG_WINDOW_STATE_WAITING_FOR_CHOICE ||
                       gMessagePrinters[i].windowState == MSG_WINDOW_STATE_SCROLLING_BACK ||
                       gMessagePrinters[i].stateFlags & MSG_STATE_FLAG_10000 ||
                       gMessagePrinters[i].stateFlags & MSG_STATE_FLAG_20000)
            {
                msg_draw_choice_pointer(&gMessagePrinters[i]);
            }
        }
    }
}

Referenced by gfx_draw_frame().

◆ render_workers_frontUI()

void render_workers_frontUI ( void )

Definition at line 150 of file worker.c.

                                  {
    s32 i;
 
    for (i = 0; i < MAX_WORKERS; i++) {
        Worker* worker = (*gCurrentWorkerListPtr)[i];
        if (worker != NULL && !(worker->flags & WORKER_FLAG_SKIP_DRAW_UNTIL_UPDATE)) {
            if (worker->flags & WORKER_FLAG_FRONT_UI) {
                worker->draw();
            }
        }
    }
}

Referenced by gfx_draw_frame().

◆ render_screen_overlay_frontUI()

void render_screen_overlay_frontUI ( void )

Definition at line 476 of file screen_overlays.c.

                                         {
    if (screen_overlay_frontType != OVERLAY_NONE
        && screen_overlay_frontZoom != -1.0f
        && gGameStatusPtr->context != CONTEXT_PAUSE
    ) {
        _render_transition_stencil(screen_overlay_frontType, screen_overlay_frontZoom, &ScreenOverlays[0]);
    }
}

Referenced by gfx_draw_frame().

◆ render_curtains()

void render_curtains ( void )

Definition at line 223 of file curtains.c.

                           {
    if (gCurtainScaleGoal != gCurtainScale) {
        gCurtainScale += (gCurtainScaleGoal - gCurtainScale) * 0.1;
    }
 
    if (gCurtainFadeGoal != gCurtainFade) {
        gCurtainFade += (gCurtainFadeGoal - gCurtainFade) * 0.03;
    }
 
    if (gCurtainScale < 1.9) {
        Matrix4f m;
        f32 scale;
        s8 rgb;
 
        gDPPipeSync(gMainGfxPos++);
        gDPSetColorImage(gMainGfxPos++, G_IM_FMT_RGBA, G_IM_SIZ_16b, SCREEN_WIDTH, osVirtualToPhysical(nuGfxCfb_ptr));
        gSPDisplayList(gMainGfxPos++, &TheaterInitGfx);
 
        guFrustumF(m, -80.0f, 80.0f, -60.0f, 60.0f, 160.0f, 640.0f, 1.0f);
        guMtxF2L(m, &D_8009BAA8[0]);
 
        gSPMatrix(gMainGfxPos++, &D_8009BAA8[0], G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
 
        scale = gCurtainScale - 0.01;
        if (scale < 1.0f) {
            scale = 1.0f;
        }
 
        guPositionF(m, 0.0f, 0.0f, 0.0f, scale * 0.1, 0.0f, 0.0f, -320.0f);
 
        guMtxF2L(m, &D_8009BAA8[1]);
 
        gSPMatrix(gMainGfxPos++, &D_8009BAA8[1], G_MTX_PUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
        rgb = 255.0f - (gCurtainFade * 255.0f);
        gDPSetPrimColor(gMainGfxPos++, 0, 0, rgb, rgb, rgb, 255);
        gSPDisplayList(gMainGfxPos++, &TheaterGfx);
        gSPPopMatrix(gMainGfxPos++, G_MTX_MODELVIEW);
        gDPPipeSync(gMainGfxPos++);
    }
 
    if (gCurtainDrawCallback != NULL) {
        gCurtainDrawCallback();
    }
 
    if (!(gGameStatusPtr->contBitPattern & 1)) {
        if ((get_game_mode() == GAME_MODE_INTRO)
                || (get_game_mode() == GAME_MODE_TITLE_SCREEN)
                || (gGameStatusPtr->demoState != DEMO_STATE_NONE)) {
            s32 alpha = ((gGameStatusPtr->frameCounter) % 0x18) << 5;
 
            if (alpha > 255) {
                alpha = 255;
            }
 
            gSPDisplayList(gMainGfxPos++, &TheaterInitGfx);
            gSPDisplayList(gMainGfxPos++, &NoControllerSetupTexGfx);
            gDPSetPrimColor(gMainGfxPos++, 0, 0, 0xFF, 0x20, 0x10, alpha);
            gSPDisplayList(gMainGfxPos++, &NoControllerGfx);
        }
    }
}

Referenced by gfx_draw_frame().

◆ fio_init_flash()

void fio_init_flash ( void )

Definition at line 232 of file fio.c.

                          {
    osFlashInit();
}

Referenced by load_engine_data().

◆ func_80028838()

void func_80028838 ( void )

Definition at line 23 of file input.c.

                         {
    func_800287F0();
    D_8009A6A0 = 0;
    D_8009A6A2 = 0;
    D_8009A6A4 = 0;
    D_8009A6A6 = 0;
}

Referenced by load_engine_data().

◆ clear_screen_overlays()

void clear_screen_overlays ( void )

Definition at line 448 of file screen_overlays.c.

                                 {
    ScreenOverlay* it;
    s32 i;
 
    screen_overlay_frontType = OVERLAY_NONE;
    screen_overlay_backType  = OVERLAY_NONE;
    screen_overlay_frontZoom = -1.0f;
    screen_overlay_backZoom  = -1.0f;
 
    for (it = &ScreenOverlays[0], i = 0; i < ARRAY_COUNT(ScreenOverlays); i++, it++) {
        it->color.b = 0;
        it->color.g = 0;
        it->color.r = 0;
        it->screenPos[1][1] = 0;
        it->screenPos[1][0] = 0;
        it->screenPos[0][1] = 0;
        it->screenPos[0][0] = 0;
        it->alpha = 255.0f;
    }
}

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

◆ bgm_reset_sequence_players()

void bgm_reset_sequence_players ( void )

Definition at line 63 of file e0b30_len_b80.c.

                                      {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gMusicSettings); i++) {
        gMusicSettings[i] = BlankMusicSettings;
    }
 
    MusicTargetVolume = 8;
    MusicMaxVolume = 8;
    MusicCurrentVolume = 8;
    func_800561A4(8);
}

Referenced by load_engine_data().

◆ reset_ambient_sounds()

void reset_ambient_sounds ( void )

Definition at line 28 of file ambience.c.

                                {
    AmbientSoundData = DefaultAmbientSoundData;
}

Referenced by load_engine_data().

◆ poll_rumble()

void poll_rumble ( void )

Definition at line 10 of file rumble.c.

                       {
    nuContRmbCheck(0);
    nuContRmbModeSet(0, 2);
}

Referenced by load_engine_data().

◆ bgm_pop_song()

void bgm_pop_song ( void )

Definition at line 375 of file e0b30_len_b80.c.

                        {
    MusicSettings* musicSetting = gMusicSettings;
 
    if (gGameStatusPtr->demoState == DEMO_STATE_NONE) {
        musicSetting->flags |= MUSIC_SETTINGS_FLAG_8;
        _bgm_set_song(0, musicSetting->savedSongID, musicSetting->savedVariation, 0, 8);
    }
}

◆ bgm_push_song()

void bgm_push_song	(	s32	songID,
		s32	variation )

Definition at line 384 of file e0b30_len_b80.c.

                                              {
    MusicSettings* musicSetting = gMusicSettings;
 
    if (gGameStatusPtr->demoState == DEMO_STATE_NONE) {
        musicSetting->savedSongID = musicSetting->songID;
        musicSetting->savedVariation = musicSetting->variation;
        musicSetting->savedSongName = musicSetting->songName;
        musicSetting->flags |= MUSIC_SETTINGS_FLAG_4;
        bgm_set_song(0, songID, variation, 500, 8);
    }
}

◆ bgm_pop_battle_song()

void bgm_pop_battle_song ( void )

Definition at line 396 of file e0b30_len_b80.c.

                               {
    MusicSettings* musicSetting = gMusicSettings;
 
    if (gGameStatusPtr->demoState == DEMO_STATE_NONE) {
        if (gOverrideFlags & GLOBAL_OVERRIDES_DONT_RESUME_SONG_AFTER_BATTLE) {
            gOverrideFlags &= ~GLOBAL_OVERRIDES_DONT_RESUME_SONG_AFTER_BATTLE;
        } else {
            musicSetting->flags |= MUSIC_SETTINGS_FLAG_8;
            _bgm_set_song(0, musicSetting->savedSongID, musicSetting->savedVariation, 0, 8);
            snd_ambient_resume(0, 250);
        }
    }
}

Referenced by update_encounters_post_battle().

◆ play_ambient_sounds()

s32 play_ambient_sounds	(	s32	fadeInTime,
		s32	fadeOutTime )

Definition at line 72 of file ambience.c.

                                                   {
    AmbientSoundSettings* state = &AmbientSoundData;
 
    if (!gGameStatusPtr->musicEnabled) {
        snd_ambient_stop_quick(state->soundID);
        state->flags &= ~1;
        return 1;
    }
 
    if (state->soundID == soundID) {
        return 2;
    }
 
    state->soundID = soundID;
    state->fadeTime = fadeTime;
    state->fadeState = AMBIENT_SOUND_FADE_OUT;
    return 1;
}

◆ get_fortress_key_count()

s32 get_fortress_key_count ( void )

◆ subtract_fortress_keys()

s32 subtract_fortress_keys ( s32 amt )

◆ add_star_points()

s32 add_star_points ( s32 amt )

Definition at line 2097 of file inventory.c.

                             {
    PlayerData* playerData = &gPlayerData;
    s8 newSP = playerData->starPoints + amt;
 
    // TODO: probably a macro!
    playerData->starPoints = newSP;
    if (newSP > 100) {
        playerData->starPoints = 100;
    }
 
    // TODO: probably a macro!
    newSP = playerData->starPoints;
    if (newSP < 0) {
        playerData->starPoints = 0;
    }
    return gPlayerData.starPoints;
}

◆ add_star_pieces()

s32 add_star_pieces ( s32 amt )

Definition at line 2115 of file inventory.c.

                             {
    PlayerData* playerData = &gPlayerData;
    s32 newSP = playerData->starPieces;
 
    newSP += amt;
    if (newSP > MAX_STAR_PIECES) {
        newSP = MAX_STAR_PIECES;
    }
    if (newSP < 0) {
        newSP = 0;
    }
    playerData->starPieces = newSP;
 
    if (amt > 0) {
        playerData->starPiecesCollected += amt;
    }
 
    return playerData->starPieces;
}

◆ make_item_entity_at_player()

s32 make_item_entity_at_player	(	s32	itemID,
		s32	arg1,
		s32	pickupMsgFlags )

Definition at line 690 of file item_entity.c.

                                                                             {
    PlayerStatus* playerStatus = &gPlayerStatus;
    ItemEntity* item;
    Shadow* shadow;
    s32 i;
    f32 posX;
    f32 posY;
    f32 posZ;
    f32 depth;
    s32 id;
 
    for (i = 0; i < MAX_ITEM_ENTITIES; i++) {
        if (gCurrentItemEntities[i] == NULL) {
            break;
        }
    }
    ASSERT(i < MAX_ITEM_ENTITIES);
    id = i;
 
    gCurrentItemEntities[id] = item = heap_malloc(sizeof(*item));
    ItemEntitiesCreated++;
    ASSERT(item != NULL);
 
    itemID &= 0xFFFF;
    item->renderGroup = -1;
    item->flags = (ITEM_ENTITY_FLAG_CAM0 | ITEM_ENTITY_FLAG_CAM1 | ITEM_ENTITY_FLAG_CAM2);
    item->flags |= ITEM_ENTITY_FLAG_10;
    item->flags |= ITEM_ENTITY_FLAG_2000000;
    if (category != ITEM_TYPE_CONSUMABLE) {
        item->flags |= ITEM_ENTITY_FLAG_4000000;
    }
    item->pickupMsgFlags = pickupMsgFlags;
    item->spawnType = ITEM_SPAWN_AT_PLAYER;
    item->state = ITEM_PICKUP_STATE_INIT;
    item->boundVar = 0;
    item->pos.x = playerStatus->pos.x;
    item->pos.y = playerStatus->pos.y;
    item->pos.z = playerStatus->pos.z;
 
    item->shadowIndex = -1;
    item->nextUpdate = 1;
    item->lastPos.x = -9999;
    item->lastPos.y = -9999;
    item->lastPos.z = -9999;
    item->scale = 1.0f;
    item->itemID = itemID;
    item->physicsData = NULL;
    item->pickupDelay = 0;
    item->spawnAngle = 0;
    item->flags |= ITEM_ENTITY_RESIZABLE;
 
    if (gItemTable[itemID].typeFlags & ITEM_TYPE_FLAG_ENTITY_FULLSIZE) {
        item->flags = (item->flags | ITEM_ENTITY_FLAG_FULLSIZE) & ~ITEM_ENTITY_RESIZABLE;
    }
 
    if (ItemEntityAlternatingSpawn != 0) {
        item->flags |= ITEM_ENTITY_FLAG_ODD_SPAWN_PARITY;
    }
    ItemEntityAlternatingSpawn = 1 - ItemEntityAlternatingSpawn;
 
    item->shadowIndex = create_shadow_type(SHADOW_VARYING_CIRCLE, item->pos.x, item->pos.y, item->pos.z);
    shadow = get_shadow_by_index(item->shadowIndex);
    shadow->flags |= ENTITY_FLAG_HIDDEN;
 
    posX = item->pos.x;
    posY = item->pos.y + 12.0f;
    posZ = item->pos.z;
    depth = 1000.0f;
    npc_raycast_down_sides(COLLIDER_FLAG_IGNORE_NPC, &posX, &posY, &posZ, &depth);
    shadow->pos.x = posX;
    shadow->pos.y = posY;
    shadow->pos.z = posZ;
 
    shadow->rot.x = gGameStatusPtr->playerGroundTraceAngles.x;
    shadow->rot.y = 0.0f;
    shadow->rot.z = gGameStatusPtr->playerGroundTraceAngles.z;
    set_standard_shadow_scale(shadow, depth * 0.5f);
 
    item_entity_load(item);
    if (item->itemID == ITEM_COIN) {
        sparkle_script_init(item, &SparkleScript_Coin);
        sparkle_script_update(item);
    }
    return id;
}

◆ set_action_state()

void set_action_state ( s32 actionState )

Definition at line 209 of file 7E9D0.c.

                                       {
    PlayerStatus* playerStatus = &gPlayerStatus;
    PlayerData* playerData = &gPlayerData;
    PlayerSpinState* spinState = &gPlayerSpinState;
 
    if (playerStatus->flags & PS_FLAG_SPECIAL_JUMP) {
        playerStatus->flags &= ~PS_FLAG_SPECIAL_JUMP;
        enable_player_input();
    }
 
    if (playerStatus->animFlags & PA_FLAG_8BIT_MARIO) {
        if (actionState >= ACTION_STATE_IDLE && actionState < ACTION_STATE_TALK) {
            playerStatus->prevActionState = playerStatus->actionState;
            playerStatus->actionState = actionState;
            playerStatus->flags |= PS_FLAG_ACTION_STATE_CHANGED;
        }
        return;
    }
 
    if (actionState == ACTION_STATE_HIT_FIRE || actionState == ACTION_STATE_HIT_LAVA) {
        s8 partner;
 
        if (playerStatus->hazardType == HAZARD_TYPE_FIRE_BAR) {
            actionState = ACTION_STATE_HIT_FIRE;
        }
 
        // Whilst Sushie, Lakilester, or Parakarry's ability is active, hazards have no effect.
        partner = playerData->curPartner;
 
        if (partner == PARTNER_SUSHIE || partner == PARTNER_LAKILESTER || partner == PARTNER_PARAKARRY) {
            if (gPartnerStatus.partnerActionState != PARTNER_ACTION_NONE) {
                playerStatus->animFlags |= PA_FLAG_INTERRUPT_USE_PARTNER;
                playerStatus->flags |= PS_FLAG_HIT_FIRE;
                return;
            }
        }
    }
 
    if (actionState == ACTION_STATE_SLIDING) {
        playerStatus->flags |= PS_FLAG_SLIDING;
        playerStatus->moveFrames = 0;
        playerStatus->flags &= ~PS_FLAG_CUTSCENE_MOVEMENT;
    }
 
    playerStatus->prevActionState = playerStatus->actionState;
    if (actionState == ACTION_STATE_USE_TWEESTER) {
        playerStatus->prevActionState = ACTION_STATE_IDLE;
    }
 
    if (actionState == ACTION_STATE_ENEMY_FIRST_STRIKE) {
        playerStatus->animFlags |= PA_FLAG_INTERRUPT_USE_PARTNER;
    }
    playerStatus->actionState = actionState;
    playerStatus->flags |= PS_FLAG_ACTION_STATE_CHANGED;
 
    if (playerStatus->actionState == ACTION_STATE_SPIN) {
        return;
    }
 
    playerStatus->flags &= ~PS_FLAG_SPINNING;
    playerStatus->animFlags &= ~PA_FLAG_SPINNING;
 
    if (spinState->spinSoundID != 0) {
        sfx_stop_sound(spinState->spinSoundID);
    }
 
    if (playerStatus->specialDecorationEffect != NULL) {
        playerStatus->specialDecorationEffect->data.spin->timeLeft = 10;
        playerStatus->specialDecorationEffect = NULL;
    }
}

Referenced by action_hammer_end_swing(), action_update_first_strike(), action_update_hit_fire(), action_update_hit_lava(), action_update_idle(), action_update_idle_peach(), action_update_knockback(), action_update_land(), action_update_launch(), action_update_parasol(), action_update_peach_land(), action_update_peach_step_down_land(), action_update_pushing_block(), action_update_raise_arms(), action_update_run(), action_update_sliding(), action_update_spin(), action_update_spin_jump(), action_update_state_23(), action_update_step_down(), action_update_step_up(), action_update_step_up_peach(), action_update_tornado_jump(), action_update_use_munchlesia(), action_update_use_spinning_flower(), action_update_use_tweester(), action_update_walk(), check_input_hammer(), check_input_jump(), check_input_midair_jump(), check_input_open_menus(), check_input_spin(), check_player_action_debug(), collision_lateral_peach(), end_outta_sight_cleanup(), entity_CymbalPlant_idle(), entity_ScriptSpring_idle(), entity_SimpleSpring_set_jump_params(), entity_TriggerBlock_disable_player_input(), entity_Tweester_idle(), entity_WoodenCrate_idle(), func_802BB000_E2D930(), func_802BC274_E2EBA4(), func_802BC3A0_E2ECD0(), handle_jumping_launch(), move_player(), peach_check_for_parasol_input(), peach_force_disguise_action(), phys_main_collision_below(), phys_peach_update(), phys_player_land(), phys_update_action_state(), phys_update_jump(), player_handle_floor_collider_type(), post_battle(), post_battle(), pre_battle(), pre_battle(), pre_battle(), pre_battle(), pre_battle(), pre_battle(), reset_player_status(), start_bounce_a(), start_bounce_b(), start_falling(), update_encounters_conversation(), update_encounters_neutral(), update_encounters_post_battle(), update_item_entity_pickup(), and update_locomotion_state().

◆ get_collider_flags()

s32 get_collider_flags ( s32 colliderID )

Definition at line 481 of file collision.c.

                                       {
    if (colliderID & COLLISION_WITH_ENTITY_BIT) {
        return 0;
    } else {
        return gCollisionData.colliderList[colliderID].flags;
    }
}

Referenced by action_update_hit_fire(), action_update_knockback(), action_update_sliding(), action_update_spin_jump(), action_update_step_down(), action_update_tornado_jump(), can_dismount(), check_input_jump(), func_80262130(), npc_surface_spawn_fx(), partner_get_out(), partner_walking_follow_player(), phys_adjust_cam_on_landing(), phys_main_collision_below(), player_handle_floor_collider_type(), player_surface_spawn_fx(), try_player_footstep_sounds(), update_current_floor(), update_riding_physics(), and update_riding_physics().

◆ suggest_player_anim_always_forward()

void suggest_player_anim_always_forward ( AnimID anim )

Definition at line 913 of file 77480.c.

                                                     {
    PlayerStatus* playerStatus = &gPlayerStatus;
    AnimID newAnim = get_overriding_player_anim(anim);
 
    if (newAnim != -1) {
        playerStatus->anim = newAnim;
        playerStatus->animNotifyValue = 0;
        playerStatus->flags |= PS_FLAG_FACE_FORWARD;
    }
}

Referenced by action_update_first_strike(), action_update_hit_fire(), action_update_hit_lava(), action_update_knockback(), action_update_pushing_block(), action_update_raise_arms(), action_update_sliding(), action_update_spin(), action_update_talk(), action_update_tornado_jump(), action_update_use_munchlesia(), action_update_use_spinning_flower(), entity_GiantChest_open(), func_802BC2B4_E2EBE4(), update_item_entity_pickup(), and update_riding_physics().

◆ suggest_player_anim_allow_backward()

void suggest_player_anim_allow_backward ( AnimID anim )

Definition at line 894 of file 77480.c.

                                                     {
    PlayerStatus* playerStatus = &gPlayerStatus;
    AnimID newAnim = get_overriding_player_anim(anim);
 
    if (newAnim != -1) {
        playerStatus->anim = newAnim;
        playerStatus->animNotifyValue = 0;
        playerStatus->flags &= ~PS_FLAG_FACE_FORWARD;
    }
}

Referenced by action_update_falling(), action_update_hammer(), action_update_idle(), action_update_idle_peach(), action_update_jump(), action_update_land(), action_update_landing_on_switch(), action_update_parasol(), action_update_peach_falling(), action_update_peach_step_down(), action_update_pushing_block(), action_update_run(), action_update_sliding(), action_update_spin(), action_update_spin_jump(), action_update_step_up(), action_update_step_up_peach(), action_update_step_up_set_peach_anim(), action_update_use_munchlesia(), action_update_use_spinning_flower(), action_update_use_tweester(), action_update_walk(), action_update_walk_set_peach_anim(), entity_GiantChest_await_got_item(), entity_Padlock_push_player(), handle_jumping_land_on_switch(), initialize_jump(), player_jump(), update_encounters_post_battle(), and update_player_carry_anim().

◆ subtract_hp()

void subtract_hp ( s32 amt )

Definition at line 2204 of file inventory.c.

                          {
    PlayerData* playerData = &gPlayerData;
    s32 newHP = playerData->curHP;
 
    if (amt > 0) {
        newHP -= amt;
    }
    if (amt < 0 || newHP < 1) {
        newHP = 1;
    }
    playerData->curHP = newHP;
}

Referenced by action_update_hit_fire(), action_update_hit_lava(), and func_802BC274_E2EBA4().

◆ draw_status_ui()

void draw_status_ui ( void )

Definition at line 1422 of file inventory.c.

                          {
    update_status_bar();
    update_coin_counter();
 
    #if DX_DEBUG_MENU
    dx_debug_menu_main();
    #endif
}

Referenced by btl_draw_ui(), state_drawUI_change_map(), state_drawUI_enter_world(), and state_drawUI_world().

◆ open_status_bar_slowly()

void open_status_bar_slowly ( void )

Definition at line 1431 of file inventory.c.

                                  {
    StatusBar* statusBar = &gStatusBar;
 
    if (statusBar->hidden) {
        statusBar->showTimer = 210;
        statusBar->hidden = FALSE;
        statusBar->unk_3B = TRUE;
    }
}

Referenced by action_update_hit_fire(), action_update_hit_lava(), and check_input_status_bar().

◆ suspend_all_group()

void suspend_all_group ( s32 groupFlags )

Definition at line 846 of file script_list.c.

                                       {
    s32 i;
    Evt* scriptContextPtr;
 
    for (i = 0; i < MAX_SCRIPTS; i++) {
        scriptContextPtr = (*gCurrentScriptListPtr)[i];
        if (scriptContextPtr != NULL) {
            suspend_group_script(scriptContextPtr, groupFlags);
        }
    }
}

Referenced by evt_handle_suspend_all(), set_time_freeze_mode(), suspend_frozen_scripts(), update_encounters_neutral(), and update_encounters_pre_battle().

◆ kill_script()

void kill_script ( Evt * instanceToKill )

Definition at line 609 of file script_list.c.

                                      {
    Evt* childScript;
    Evt* blockingParent;
    s32 j;
    s32 i;
 
    for (i = 0; i < MAX_SCRIPTS; i++) {
        if ((*gCurrentScriptListPtr)[i] == instanceToKill) {
            break;
        }
    }
 
    if (i >= MAX_SCRIPTS) {
        return;
    }
 
    childScript = instanceToKill->childScript;
    if (childScript != NULL) {
        kill_script(childScript);
    }
 
    for (j = 0; j < MAX_SCRIPTS; j++) {
        Evt* tempScriptInstance = (*gCurrentScriptListPtr)[j];
        if (tempScriptInstance != NULL) {
            if (tempScriptInstance->parentScript == instanceToKill) {
                kill_script(tempScriptInstance);
            }
        }
    }
 
    blockingParent = instanceToKill->blockingParent;
    if (blockingParent != NULL) {
        blockingParent->childScript = NULL;
        blockingParent->stateFlags &= ~EVT_FLAG_BLOCKED_BY_CHILD;
 
        for (j = 0; j < ARRAY_COUNT(blockingParent->varTable); j++) {
            blockingParent->varTable[j] = instanceToKill->varTable[j];
        }
 
        for (j = 0; j < ARRAY_COUNT(blockingParent->varFlags); j++) {
            blockingParent->varFlags[j] = instanceToKill->varFlags[j];
        }
    }
 
    if (instanceToKill->userData != NULL) {
        heap_free(instanceToKill->userData);
        instanceToKill->userData = NULL;
    }
 
    heap_free((*gCurrentScriptListPtr)[i]);
    (*gCurrentScriptListPtr)[i] = NULL;
    gNumScripts--;
}

Referenced by evt_handle_end_child_thread(), evt_handle_end_thread(), evt_handle_return(), func_802C3C10(), kill_all_scripts(), kill_script(), and kill_script_by_ID().

◆ exec_entity_commandlist()

void exec_entity_commandlist ( Entity * entity )

Definition at line 313 of file entity.c.

                                             {
    while (step_entity_commandlist(entity));
}

Referenced by action_update_use_spinning_flower(), entity_base_switch_animate_scale(), entity_BellbellPlant_idle(), entity_block_handle_collision(), entity_BlueWarpPipe_check_if_active(), entity_BlueWarpPipe_enter_pipe_update(), entity_BlueWarpPipe_idle(), entity_BlueWarpPipe_rise_up(), entity_BlueWarpPipe_wait_for_player_to_get_off(), entity_BlueWarpPipe_wait_player_move_to_center(), Entity_BoardedFloor_idle(), Entity_BoardedFloor_update_fragments(), entity_BombableRock_idle(), entity_BombableRock_update_fragments(), entity_Chest_idle(), entity_Chest_open(), entity_GiantChest_await_got_item(), entity_GiantChest_open(), entity_GreenStompSwitch_extend(), entity_GreenStompSwitch_idle(), entity_GreenStompSwitch_retract(), entity_HeartBlock_show_tutorial_message(), entity_HeartBlock_wait_for_close_tutorial(), entity_HeartBlockContent__anim_heal(), entity_HeartBlockContent_anim_idle(), entity_HiddenPanel_flip_over(), entity_HiddenPanel_idle(), entity_HugeBlueSwitch_idle(), entity_inactive_block_hit_anim(), entity_inactive_block_recoil_anim(), entity_ItemBlock_check_if_inactive(), entity_MulticoinBlock_idle(), entity_Padlock_idle(), entity_PinkFlower_idle(), entity_RedSwitch_animate_scale(), entity_RedSwitch_wait_and_reset(), entity_SaveBlock_show_tutorial_message(), entity_SaveBlock_wait_for_close_choice(), entity_SaveBlock_wait_for_close_result(), entity_SaveBlock_wait_for_close_tutorial(), entity_ScriptSpring_idle(), entity_shattering_idle(), entity_SimpleSpring_idle(), entity_small_switch_idle(), entity_StarBoxLauncher_check_launch(), entity_StarBoxLauncher_launch(), entity_TrumpetPlant_idle(), entity_WoodenCrate_idle(), entity_WoodenCrate_update_fragments(), func_802BB0A0_E2D9D0(), func_802BC050_E2E980(), and func_802BC99C_E312EC().

◆ show_start_recovery_shimmer()

void show_start_recovery_shimmer	(	f32	x,
		f32	y,
		f32	z,
		s32	arg3 )

Definition at line 4 of file fx_api.c.

                                                               {
    fx_stars_shimmer(1, x, y, z, amt + 30, amt + 30, (amt / 2) + 10, 30);
}

◆ show_recovery_shimmer()

void show_recovery_shimmer	(	f32	x,
		f32	y,
		f32	z,
		s32	arg3 )

Definition at line 8 of file fx_api.c.

                                                         {
    fx_stars_shimmer(2, x, y, z, amt + 30, amt + 30, (amt / 2) + 10, 30);
}

◆ show_next_damage_popup()

void show_next_damage_popup	(	f32	x,
		f32	y,
		f32	z,
		s32	damageAmount,
		s32	angle )

Definition at line 2295 of file 190B20.c.

                                                                                    {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gDamageCountEffects); i++) {
        if (gDamageCountEffects[i] == NULL) {
            break;
        }
    }
 
    if (i > ARRAY_COUNT(gDamageCountEffects) - 1) {
        i = 0;
        gDamageCountEffects[i]->data.damageIndicator->timeLeft = 5;
        gDamageCountEffects[i] = NULL;
    }
 
    if (angle == 0) {
        angle = -55;
    } else {
        angle = 55;
    }
 
    fx_damage_indicator(0, posX, posY, posZ, 10.0f, angle, damageAmt, &gDamageCountEffects[i]);
    gDamageCountTimers[i] = 40;
}

Referenced by calc_enemy_damage_target(), calc_item_damage_enemy(), calc_partner_damage_enemy(), calc_player_damage_enemy(), dispatch_damage_event_actor(), dispatch_damage_event_partner(), and dispatch_damage_event_player().

◆ add_xz_vec3f()

void add_xz_vec3f	(	Vec3f *	vector,
		f32	speed,
		f32	angleDeg )

Definition at line 1139 of file 190B20.c.

                                                          {
    f32 angleRad = DEG_TO_RAD(angleDeg);
    f32 sinAngleRad = sin_rad(angleRad);
    f32 cosAngleRad = cos_rad(angleRad);
 
    vector->x += speed * sinAngleRad;
    vector->z += -speed * cosAngleRad;
}

◆ add_xz_vec3f_copy1()

void add_xz_vec3f_copy1	(	Vec3f *	vector,
		f32	speed,
		f32	angleDeg )

Definition at line 1148 of file 190B20.c.

                                                                {
    f32 angleRad = DEG_TO_RAD(angleDeg);
    f32 sinAngleRad = sin_rad(angleRad);
    f32 cosAngleRad = cos_rad(angleRad);
 
    vector->x += speed * sinAngleRad;
    vector->z += -speed * cosAngleRad;
}

◆ add_xz_vec3f_copy2()

void add_xz_vec3f_copy2	(	Vec3f *	vector,
		f32	speed,
		f32	angleDeg )

Definition at line 1157 of file 190B20.c.

                                                                {
    f32 angleRad = DEG_TO_RAD(angleDeg);
    f32 sinAngleRad = sin_rad(angleRad);
    f32 cosAngleRad = cos_rad(angleRad);
 
    vector->x += speed * sinAngleRad;
    vector->z += -speed * cosAngleRad;
}

◆ play_movement_dust_effects()

void play_movement_dust_effects	(	s32	var0,
		f32	xPos,
		f32	yPos,
		f32	zPos,
		f32	angleDeg )

Definition at line 1166 of file 190B20.c.

                                                                                      {
    f32 theta;
    f32 sinTheta;
    f32 cosTheta;
 
    if (var0 == 2) {
        fx_landing_dust(0, xPos, yPos + 0.0f, zPos, D_802938A4);
    } else if (var0 == 1) {
        D_802938A8 = 4;
    } else if (D_802938A8++ >= 4) {
        D_802938A8 = 0;
        theta = DEG_TO_RAD(clamp_angle(-angleDeg));
        sinTheta = sin_rad(theta);
        cosTheta = cos_rad(theta);
        fx_walking_dust(
            0,
            xPos + (sinTheta * 24.0f * 0.2f),
            yPos + 1.5f,
            zPos + (cosTheta * 24.0f * 0.2f),
            sinTheta,
            cosTheta
        );
    }
}

◆ draw_prev_frame_buffer_at_screen_pos()

void draw_prev_frame_buffer_at_screen_pos	(	s32	x1,
		s32	y1,
		s32	x2,
		s32	y2,
		f32	alpha )

Definition at line 78 of file screen_render_util.c.

                                                                                     {
    s32 minX;
    s32 minY;
    s32 maxX;
    s32 maxY;
 
    maxX = x2;
    maxY = y2;
    if (maxX < x1) {
        minX = maxX;
        maxX = x1;
    } else {
        minX = x1;
    }
    if (maxY < y1) {
        minY = maxY;
        maxY = y1;
    } else {
        minY = y1;
    }
    if (minX < maxX && minY < maxY) {
        if (minX < 0) {
            minX = 0;
        }
        if (minY < 0) {
            minY = 0;
        }
        if (maxX < 0) {
            maxX = 0;
        }
        if (maxY < 0) {
            maxY = 0;
        }
        if (minX >= SCREEN_WIDTH) {
            minX = SCREEN_WIDTH - 1;
        }
        if (minY >= SCREEN_HEIGHT) {
            minY = SCREEN_HEIGHT - 1;
        }
        if (maxX >= SCREEN_WIDTH) {
            maxX = SCREEN_WIDTH - 1;
        }
        if (maxY >= SCREEN_HEIGHT) {
            maxY = SCREEN_HEIGHT - 1;
        }
        if (minX != maxX && minY != maxY) {
            appendGfx_draw_prev_frame_buffer(minX, minY, maxX, maxY, alpha);
        }
    }
}

◆ func_8013A4D0()

void func_8013A4D0 ( void )

Definition at line 266 of file imgfx.c.

                         {
    s32 i;
 
    imgfx_vtxBuf = ImgFXVtxBuffers[gCurrentDisplayContextIndex];
    imgfx_vtxCount = 0;
    imgfx_init_instance(&(*ImgFXInstances)[0]);
 
    (*ImgFXInstances)[0].flags |= IMGFX_FLAG_VALID;
 
    for (i = 1; i < ARRAY_COUNT(*ImgFXInstances); i++) {
        if (((*ImgFXInstances)[i].flags & IMGFX_FLAG_VALID) && (*ImgFXInstances)[i].lastAnimCmd != IMGFX_SET_ANIM) {
            imgfx_cache_instance_data(&(*ImgFXInstances)[i]);
        }
    }
 
    for (i = 1; i < ARRAY_COUNT(*ImgFXInstances); i++) {
        if ((*ImgFXInstances)[i].flags & IMGFX_FLAG_VALID && (*ImgFXInstances)[i].colorBuf != NULL) {
            if ((*ImgFXInstances)[i].lastColorCmd == IMGFX_COLOR_BUF_SET_MULTIPLY) {
                continue;
            }
            if ((*ImgFXInstances)[i].lastColorCmd == IMGFX_COLOR_BUF_SET_MODULATE) {
                continue;
            }
            general_heap_free((*ImgFXInstances)[i].colorBuf);
            (*ImgFXInstances)[i].colorBuf = NULL;
            (*ImgFXInstances)[i].colorBufCount = 0;
        }
    }
}

Referenced by spr_update_player_raster_cache().

◆ btl_draw_ui()

void btl_draw_ui ( void )

Definition at line 486 of file 16C8E0.c.

                       {
    s32 changed = FALSE;
    s32 state;
 
    state = gBattleState;
    if (gBattleState != gLastDrawBattleState) {
        state = gLastDrawBattleState;
        gLastDrawBattleState = gBattleState;
        changed = TRUE;
    } else {
        switch (state) {
            case BATTLE_STATE_NEGATIVE_1:
                btl_update_starpoints_display();
                btl_draw_enemy_health_bars();
                draw_status_ui();
                return;
            case BATTLE_STATE_0:
                return;
        }
    }
 
    btl_update_starpoints_display();
    btl_draw_enemy_health_bars();
 
    if (!changed) {
        switch (state) {
            case BATTLE_STATE_NORMAL_START:
                btl_state_draw_normal_start();
                break;
            case BATTLE_STATE_BEGIN_PLAYER_TURN:
                btl_state_draw_begin_player_turn();
                break;
            case BATTLE_STATE_BEGIN_PARTNER_TURN:
                btl_state_draw_begin_partner_turn();
                break;
            case BATTLE_STATE_9:
                btl_state_draw_9();
                break;
            case BATTLE_STATE_BEGIN_TURN:
                btl_state_draw_begin_turn();
                break;
            case BATTLE_STATE_END_TURN:
                btl_state_draw_end_turn();
                break;
            case BATTLE_STATE_SWITCH_TO_PLAYER:
                btl_state_draw_switch_to_player();
                break;
            case BATTLE_STATE_SWITCH_TO_PARTNER:
                btl_state_draw_switch_to_partner();
                break;
            case BATTLE_STATE_PREPARE_MENU:
                btl_state_draw_prepare_menu();
                break;
            case BATTLE_STATE_PLAYER_MENU:
                btl_state_draw_player_menu();
                break;
            case BATTLE_STATE_PARTNER_MENU:
                btl_state_draw_partner_menu();
                break;
            case BATTLE_STATE_TWINK_MENU:
                btl_state_draw_twink_menu();
                break;
            case BATTLE_STATE_PEACH_MENU:
                btl_state_draw_peach_menu();
                break;
            case BATTLE_STATE_SELECT_TARGET:
                btl_state_draw_select_target();
                break;
            case BATTLE_STATE_PLAYER_MOVE:
                btl_state_draw_player_move();
                break;
            case BATTLE_STATE_FIRST_STRIKE:
                btl_state_draw_first_stike();
                break;
            case BATTLE_STATE_END_PLAYER_TURN:
                btl_state_draw_end_player_turn();
                break;
            case BATTLE_STATE_END_PARTNER_TURN:
                btl_state_draw_end_partner_turn();
                break;
            case BATTLE_STATE_PARTNER_FIRST_STRIKE:
                btl_state_draw_partner_striking_first();
                break;
            case BATTLE_STATE_ENEMY_MOVE:
                btl_state_draw_enemy_move();
                break;
            case BATTLE_STATE_NEXT_ENEMY:
                btl_state_draw_next_enemy();
                break;
            case BATTLE_STATE_PARTNER_MOVE:
                btl_state_draw_partner_move();
                break;
            case BATTLE_STATE_VICTORY:
                btl_state_draw_victory();
                break;
            case BATTLE_STATE_END_BATTLE:
                btl_state_draw_end_battle();
                break;
            case BATTLE_STATE_CHANGE_PARTNER:
                btl_state_draw_change_partner();
                break;
            case BATTLE_STATE_RUN_AWAY:
                btl_state_draw_run_away();
                break;
            case BATTLE_STATE_DEFEND:
                btl_state_draw_defend();
                break;
            case BATTLE_STATE_DEFEAT:
                btl_state_draw_defeat();
                break;
            case BATTLE_STATE_28:
                btl_state_draw_1C();
                break;
            case BATTLE_STATE_END_TRAINING_BATTLE:
                btl_state_draw_end_training_battle();
                break;
            case BATTLE_STATE_ENEMY_FIRST_STRIKE:
                btl_state_draw_enemy_striking_first();
                break;
            case BATTLE_STATE_34:
                btl_state_draw_22();
                break;
            case BATTLE_STATE_CELEBRATION:
                btl_state_draw_celebration();
                break;
            case BATTLE_STATE_END_DEMO_BATTLE:
                btl_state_draw_end_demo_battle();
                break;
        }
    }
    btl_popup_messages_draw_ui();
    draw_status_ui();
}

Referenced by state_drawUI_battle().

◆ btl_restore_world_cameras()

void btl_restore_world_cameras ( void )

Definition at line 1085 of file 16C8E0.c.

                                     {
    PlayerStatus* playerStatus = &gPlayerStatus;
    PlayerData* playerData = &gPlayerData;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gCameras); i++) {
        gCameras[i] = SavedWorldCameras[i];
    }
 
    gCurrentCameraID = CAM_DEFAULT;
    playerStatus->pos.x = SavedWorldPlayerPosX;
    playerStatus->pos.y = SavedWorldPlayerPosY;
    playerStatus->pos.z = SavedWorldPlayerPosZ;
 
    if (bSavedOverrideFlags & GLOBAL_OVERRIDES_ENABLE_FLOOR_REFLECTION) {
        gOverrideFlags |= GLOBAL_OVERRIDES_ENABLE_FLOOR_REFLECTION;
    } else {
        gOverrideFlags &= ~GLOBAL_OVERRIDES_ENABLE_FLOOR_REFLECTION;
    }
 
    if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
        playerData->curPartner = bSavedPartner;
    }
}

Referenced by state_step_end_battle().

◆ btl_popup_messages_draw_ui()

void btl_popup_messages_draw_ui ( void )

Definition at line 316 of file popup_messages.c.

                                      {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(popupMessages); i++) {
        PopupMessage* popup = &popupMessages[i];
        if (popup->active && popup->renderUIFunc != NULL) {
            popup->renderUIFunc(popup);
        }
    }
}

Referenced by btl_draw_ui().

◆ btl_cam_set_target_pos()

void btl_cam_set_target_pos	(	f32	x,
		f32	y,
		f32	z )

Definition at line 1962 of file camera.c.

                                                 {
    if (!BattleCam_IsFrozen) {
        BattleCam_PosX = x;
        BattleCam_PosY = y;
        BattleCam_PosZ = z;
    }
}

Referenced by btl_cam_use_preset_impl(), and btl_state_update_change_partner().

◆ btl_cam_unfreeze()

void btl_cam_unfreeze ( void )

Definition at line 2002 of file camera.c.

                            {
    BattleCam_IsFrozen = FALSE;
}

Referenced by btl_state_update_end_battle().

◆ deduct_current_move_fp()

void deduct_current_move_fp ( void )

Definition at line 961 of file 190B20.c.

                                  {
    BattleStatus* battleStatus = &gBattleStatus;
    PlayerData* playerData = &gPlayerData;
    Actor* actor = battleStatus->playerActor;
    s32 fpCost = gMoveTable[battleStatus->selectedMoveID].costFP;
 
    if (fpCost != 0) {
        fpCost -= player_team_is_ability_active(actor, ABILITY_FLOWER_SAVER);
        fpCost -= player_team_is_ability_active(actor, ABILITY_FLOWER_FANATIC) * 2;
        if (fpCost < 1) {
            fpCost = 1;
        }
    }
 
    playerData->curFP -= fpCost;
}

Referenced by btl_state_update_change_partner(), and btl_state_update_partner_move().

◆ load_partner_actor()

void load_partner_actor ( void )

Definition at line 1422 of file 190B20.c.

                              {
    PlayerData* playerData = &gPlayerData;
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* partnerActor;
    ActorBlueprint* actorBP;
    Evt* takeTurnScript;
    s32 partCount;
    s32 currentPartner;
    PartnerDMAData* partnerData;
    f32 x;
    f32 y;
    f32 z;
    ActorPart* part;
    s32 i;
    s32 i2;
 
    currentPartner = playerData->curPartner;
    battleStatus->partnerActor = NULL;
 
    if (currentPartner != PARTNER_NONE) {
        partnerData = &bPartnerDmaTable[currentPartner];
        actorBP = partnerData->ActorBlueprint;
 
        ASSERT(actorBP != NULL);
 
        nuPiReadRom(partnerData->dmaStart, partnerData->dmaDest, partnerData->dmaEnd - partnerData->dmaStart);
        if ((gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) || (gGameStatusPtr->demoBattleFlags & DEMO_BTL_FLAG_PARTNER_ACTING)) {
            x = -95.0f;
            y = partnerData->y;
            z = 0.0f;
            gBattleStatus.flags1 |= BS_FLAGS1_PLAYER_IN_BACK;
        } else {
            x = -130.0f;
            y = partnerData->y;
            z = -10.0f;
        }
        partCount = actorBP->partCount;
        battleStatus->partnerActor = heap_malloc(sizeof(*partnerActor));
        partnerActor = battleStatus->partnerActor;
 
        ASSERT(partnerActor != NULL);
 
        actorBP->level = playerData->partners[playerData->curPartner].level;
        partnerActor->unk_134 = battleStatus->unk_93++;
        partnerActor->footStepCounter = 0;
        partnerActor->actorBlueprint = actorBP;
        partnerActor->actorType = actorBP->type;
        partnerActor->flags = actorBP->flags;
        partnerActor->homePos.x = partnerActor->curPos.x = x;
        partnerActor->homePos.y = partnerActor->curPos.y = y;
        partnerActor->homePos.z = partnerActor->curPos.z = z;
        partnerActor->headOffset.x = 0;
        partnerActor->headOffset.y = 0;
        partnerActor->headOffset.z = 0;
        partnerActor->curHP = actorBP->maxHP;
        partnerActor->numParts = partCount;
        partnerActor->idleSource = NULL;
        partnerActor->takeTurnSource = actorBP->initScript;
        partnerActor->handleEventSource = NULL;
        partnerActor->handlePhaseSource = NULL;
        partnerActor->idleScript = NULL;
        partnerActor->takeTurnScript = NULL;
        partnerActor->handleEventScript = NULL;
        partnerActor->handlePhaseScript = NULL;
        partnerActor->turnPriority = 0;
        partnerActor->enemyIndex = 0;
        partnerActor->yaw = 0.0f;
        partnerActor->rot.x = 0.0f;
        partnerActor->rot.y = 0.0f;
        partnerActor->rot.z = 0.0f;
        partnerActor->rotPivotOffset.x = 0;
        partnerActor->rotPivotOffset.y = 0;
        partnerActor->rotPivotOffset.z = 0;
        partnerActor->scale.x = 1.0f;
        partnerActor->scale.y = 1.0f;
        partnerActor->scale.z = 1.0f;
        partnerActor->scaleModifier.x = 1.0f;
        partnerActor->scaleModifier.y = 1.0f;
        partnerActor->scaleModifier.z = 1.0f;
        partnerActor->verticalRenderOffset = 0;
        partnerActor->size.x = actorBP->size.x;
        partnerActor->size.y = actorBP->size.y;
        partnerActor->healthBarPos.x = partnerActor->homePos.x;
        partnerActor->healthBarPos.y = partnerActor->homePos.y;
        partnerActor->healthBarPos.z = partnerActor->homePos.z;
        partnerActor->scalingFactor = 1.0f;
        partnerActor->attackResultEffect = NULL;
        partnerActor->actionRatingCombo = 0;
        partnerActor->actionRatingTime = 0;
        partnerActor->statusIconOffset.x = 0;
        partnerActor->statusIconOffset.y = 0;
        partnerActor->statusTextOffset.x = 0;
        partnerActor->statusTextOffset.y = 0;
        partnerActor->renderMode = RENDER_MODE_ALPHATEST;
        partnerActor->actorID = ACTOR_PARTNER;
        partnerActor->statusTable = actorBP->statusTable;
        partnerActor->debuff = 0;
        partnerActor->debuffDuration = 0;
        partnerActor->staticStatus = 0;
        partnerActor->staticDuration = 0;
        partnerActor->stoneStatus = 0;
        partnerActor->stoneDuration = 0;
        partnerActor->koStatus = 0;
        partnerActor->koDuration = 0;
        partnerActor->transparentStatus = 0;
        partnerActor->transparentDuration = 0;
        partnerActor->isGlowing = FALSE;
        partnerActor->unk_21E = 0;
        partnerActor->disableDismissTimer = 0;
        partnerActor->attackBoost = 0;
        partnerActor->defenseBoost = 0;
        partnerActor->chillOutAmount = 0;
        partnerActor->chillOutTurns = 0;
        partnerActor->statusAfflicted = 0;
        partnerActor->actorTypeData1[0] = bActorSoundTable[partnerActor->actorType].walk[0];
        partnerActor->actorTypeData1[1] = bActorSoundTable[partnerActor->actorType].walk[1];
        partnerActor->actorTypeData1[2] = bActorSoundTable[partnerActor->actorType].fly[0];
        partnerActor->actorTypeData1[3] = bActorSoundTable[partnerActor->actorType].fly[1];
        partnerActor->actorTypeData1[4] = bActorSoundTable[partnerActor->actorType].jump;
        partnerActor->actorTypeData1[5] = bActorSoundTable[partnerActor->actorType].hurt;
        partnerActor->actorTypeData1b[0] = bActorSoundTable[partnerActor->actorType].delay[0];
        partnerActor->actorTypeData1b[1] = bActorSoundTable[partnerActor->actorType].delay[1];
 
        for (i2 = 0; i2 < ARRAY_COUNT(partnerActor->loopingSoundID); i2++) {
            partnerActor->loopingSoundID[i2] = 0;
        }
 
        part = heap_malloc(sizeof(*part));
        partnerActor->partsTable = part;
 
        ASSERT(part != NULL);
 
        for (i = 0; i < partCount; i++) {
            ActorPartBlueprint* ActorPartBlueprint = &actorBP->partsData[i];
            part->decorationTable = NULL;
            part->staticData = ActorPartBlueprint;
 
            part->flags = ActorPartBlueprint->flags | ACTOR_PART_FLAG_NO_SHADOW;
            part->targetFlags = 0;
 
            part->partOffsetFloat.x = part->partOffset.x = ActorPartBlueprint->posOffset.x;
            part->partOffsetFloat.y = part->partOffset.y = ActorPartBlueprint->posOffset.y;
            part->partOffsetFloat.z = part->partOffset.z = ActorPartBlueprint->posOffset.z;
 
            part->visualOffset.x = 0;
            part->visualOffset.y = 0;
            part->visualOffset.z = 0;
            part->absolutePos.x = 0.0f;
            part->absolutePos.y = 0.0f;
            part->absolutePos.z = 0.0f;
            part->defenseTable = ActorPartBlueprint->defenseTable;
            part->idleAnimations = ActorPartBlueprint->idleAnimations;
            part->eventFlags = ActorPartBlueprint->eventFlags;
            part->elementalImmunities = ActorPartBlueprint->elementImmunityFlags;
            part->opacity = ActorPartBlueprint->opacity;
            part->size.y = partnerActor->size.y;
            part->size.x = partnerActor->size.x;
            part->yaw = 0.0f;
            part->targetOffset.x = ActorPartBlueprint->targetOffset.x;
            part->targetOffset.y = ActorPartBlueprint->targetOffset.y;
            part->targetPriorityOffset = 0;
            part->rotPivotOffset.x = 0;
            part->rotPivotOffset.y = 0;
            part->rotPivotOffset.z = 0;
            part->rot.x = 0.0f;
            part->rot.y = 0.0f;
            part->rot.z = 0.0f;
            part->scale.x = 1.0f;
            part->scale.y = 1.0f;
            part->scale.z = 1.0f;
            part->verticalStretch = 1;
            part->palAnimPosOffset[0] = 0;
            part->palAnimPosOffset[1] = 0;
            part->partTypeData[0] = bActorSoundTable[partnerActor->actorType].walk[0];
            part->partTypeData[1] = bActorSoundTable[partnerActor->actorType].walk[1];
            part->partTypeData[2] = bActorSoundTable[partnerActor->actorType].fly[0];
            part->partTypeData[3] = bActorSoundTable[partnerActor->actorType].fly[1];
            part->partTypeData[4] = bActorSoundTable[partnerActor->actorType].jump;
            part->partTypeData[5] = bActorSoundTable[partnerActor->actorType].hurt;
            part->actorTypeData2b[0] = bActorSoundTable[partnerActor->actorType].delay[0];
            part->actorTypeData2b[1] = bActorSoundTable[partnerActor->actorType].delay[1];
 
            if (part->idleAnimations != NULL) {
                DecorationTable* decorations;
                s32 j;
 
                part->decorationTable  = heap_malloc(sizeof(*decorations));
                decorations = part->decorationTable;
 
                ASSERT(decorations != NULL);
 
                decorations->paletteAdjustment = ACTOR_PAL_ADJUST_NONE;
                decorations->glowState = GLOW_PAL_OFF;
                decorations->flashState = 0;
                decorations->flashEnabled = FLASH_PAL_OFF;
                decorations->blurUnused = 0;
                decorations->blurBufferPos = 0;
 
                for (j = 0; j < ARRAY_COUNT(decorations->posX); j++) {
                    decorations->posX[j] = partnerActor->curPos.x;
                    decorations->posY[j] = partnerActor->curPos.y;
                    decorations->posZ[j] = partnerActor->curPos.z;
                }
 
                decorations->blurDrawCount = 3;
                decorations->blurEnableCount = 0;
                decorations->blurDisableDelay = 0;
 
                for (j = 0; j < ARRAY_COUNT(decorations->effect); j++) {
                    decorations->effect[j] = NULL;
                    decorations->type[j] = 0;
                }
            }
 
            if (!(part->flags & ACTOR_PART_FLAG_SKIP_MOVEMENT_ALLOC)) {
                part->movement = heap_malloc(sizeof(*part->movement));
                ASSERT(part->movement != NULL);
            }
 
            part->animationRate = 1.0f;
            part->curAnimation = 0;
            part->spriteInstanceID = -1;
 
            if (part->idleAnimations != NULL) {
                part->curAnimation = get_npc_anim_for_status(part->idleAnimations, 1);
                part->spriteInstanceID = spr_load_npc_sprite(part->curAnimation | SPRITE_ID_TAIL_ALLOCATE, NULL);
            }
 
            if (i + 1 >= partCount) {
                part->nextPart = NULL;
                continue;
            }
 
            part->nextPart = heap_malloc(sizeof(*part->nextPart));
            part = part->nextPart;
            if (part == NULL) {
                PANIC();
            }
 
            part->nextPart = NULL;
        }
 
        partnerActor->shadow.id = create_shadow_type(SHADOW_VARYING_CIRCLE, partnerActor->curPos.x, partnerActor->curPos.y, partnerActor->curPos.z);
        partnerActor->shadowScale = partnerActor->size.x / 24.0;
        partnerActor->hudElementDataIndex = create_status_icon_set();
        partnerActor->disableEffect = fx_disable_x(0, -142.0f, 34.0f, 1.0f, 0);
        partnerActor->icePillarEffect = NULL;
 
        takeTurnScript = start_script(partnerActor->takeTurnSource, EVT_PRIORITY_A, 0);
        partnerActor->takeTurnScriptID = takeTurnScript->id;
        takeTurnScript->owner1.actorID = ACTOR_PARTNER;
    }
}

Referenced by btl_state_update_change_partner(), and btl_state_update_normal_start().

◆ dispatch_event_partner()

void dispatch_event_partner ( s32 lastEventType )

Definition at line 7 of file dmg_partner.c.

                                               {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* partnerActor = battleStatus->partnerActor;
    Evt* handleEventScript = partnerActor->handleEventScript;
    s32 onHitID = partnerActor->handleEventScriptID;
    Evt* script;
 
    partnerActor->lastEventType = lastEventType;
    script = start_script(partnerActor->handleEventSource, EVT_PRIORITY_A, EVT_FLAG_RUN_IMMEDIATELY);
    partnerActor->handleEventScript = script;
    partnerActor->handleEventScriptID = script->id;
    script->owner1.actorID = ACTOR_PARTNER;
 
    if (partnerActor->takeTurnScript != NULL) {
        kill_script_by_ID(partnerActor->takeTurnScriptID);
        partnerActor->takeTurnScript = NULL;
    }
 
    if (handleEventScript != NULL) {
        kill_script_by_ID(onHitID);
    }
}

Referenced by btl_state_update_begin_partner_turn(), btl_state_update_end_training_battle(), btl_state_update_victory(), calc_enemy_damage_target(), dispatch_damage_event_partner(), and dispatch_event_general().

◆ dispatch_event_player()

void dispatch_event_player ( s32 eventType )

Definition at line 131 of file dmg_player.c.

                                          {
    Actor* player = gBattleStatus.playerActor;
    Evt* oldOnHitScript;
    s32 oldOnHitID;
    Evt* eventScript;
 
    player->lastEventType = eventType;
 
    oldOnHitScript = player->handleEventScript;
    oldOnHitID = player->handleEventScriptID;
 
    eventScript = start_script(&EVS_Player_HandleEvent, EVT_PRIORITY_A, EVT_FLAG_RUN_IMMEDIATELY);
    player->handleEventScript = eventScript;
    player->handleEventScriptID = eventScript->id;
    eventScript->owner1.actor = NULL;
 
    if (player->takeTurnScript != NULL) {
        kill_script_by_ID(player->takeTurnScriptID);
        player->takeTurnScript = NULL;
    }
 
    if (oldOnHitScript != NULL) {
        kill_script_by_ID(oldOnHitID);
    }
}

Referenced by btl_state_update_begin_player_turn(), btl_state_update_end_training_battle(), btl_state_update_victory(), calc_enemy_damage_target(), dispatch_damage_event_player(), and dispatch_event_general().

◆ btl_are_all_enemies_defeated()

s32 btl_are_all_enemies_defeated ( void )

Definition at line 636 of file 190B20.c.

                                       {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* enemy;
    s32 enemiesStillAlive = FALSE;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
        enemy = battleStatus->enemyActors[i];
        if (enemy != NULL) {
            if(!(enemy->flags & (ACTOR_FLAG_NO_DMG_APPLY | ACTOR_FLAG_TARGET_ONLY))) {
                enemiesStillAlive = TRUE;
            }
        }
    }
    return !enemiesStillAlive;
}

Referenced by btl_check_enemies_defeated(), and btl_state_update_partner_move().

◆ btl_check_enemies_defeated()

s32 btl_check_enemies_defeated ( void )

Definition at line 653 of file 190B20.c.

                                     {
    if (btl_are_all_enemies_defeated()) {
        btl_set_state(BATTLE_STATE_VICTORY);
        return TRUE;
    }
    return FALSE;
}

Referenced by btl_state_update_9(), btl_state_update_begin_partner_turn(), btl_state_update_begin_player_turn(), btl_state_update_begin_turn(), btl_state_update_end_partner_turn(), btl_state_update_end_player_turn(), btl_state_update_enemy_move(), btl_state_update_enemy_striking_first(), btl_state_update_first_strike(), and btl_state_update_partner_striking_first().

◆ btl_check_player_defeated()

s32 btl_check_player_defeated ( void )

Definition at line 661 of file 190B20.c.

                                    {
    if (gPlayerData.curHP > 0) {
        return FALSE;
    }
    gDefeatedBattleState = gBattleState;
    gDefeatedBattleSubstate = gBattleSubState;
    btl_set_state(BATTLE_STATE_DEFEAT);
    return TRUE;
}

Referenced by btl_state_update_9(), btl_state_update_begin_partner_turn(), btl_state_update_begin_player_turn(), btl_state_update_enemy_move(), btl_state_update_enemy_striking_first(), btl_state_update_first_strike(), btl_state_update_partner_move(), btl_state_update_partner_striking_first(), and btl_state_update_player_move().

◆ btl_show_battle_message()

void btl_show_battle_message	(	s32	messageIndex,
		s32	duration )

Definition at line 576 of file popup_messages.c.

                                                             {
    PopupMessage* popup = btl_create_popup();
 
    if (popup != NULL) {
        popup->updateFunc = btl_update_message_popup;
        popup->renderUIFunc = btl_show_message_popup;
        popup->unk_00 = FALSE;
        popup->renderWorldFunc = NULL;
        popup->messageIndex = messageIndex;
        popup->duration = duration;
        popup->showMsgState = BTL_MSG_STATE_INIT;
        popup->needsInit = TRUE;
        popup->data.bonk = NULL;
        BattlePopupMessageVar = 0;
        bPopupMessage = popup;
        ActionCommandTipVisible = FALSE;
        BattleMessage_BoxPosLocked = FALSE;
        BattleMessage_CurBoxPosY = 0;
#if !VERSION_JP
        BattleMessage_CurBoxOffsetY = 0;
#endif
    }
}

Referenced by btl_main_menu_update(), btl_state_update_begin_player_turn(), btl_state_update_enemy_move(), btl_state_update_partner_move(), btl_state_update_player_move(), and btl_state_update_select_target().

◆ btl_update_ko_status()

void btl_update_ko_status ( void )

Definition at line 2869 of file 190B20.c.

                                {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    s32 koDuration = player->koDuration;
    s32 i;
 
    player->koDuration = player->debuffDuration;
    if (player->koDuration > 0) {
        player->koStatus = STATUS_KEY_DAZE;
        player->disableEffect->data.disableX->koDuration = player->koDuration;
 
        if (koDuration == 0) {
            sfx_play_sound(SOUND_INFLICT_KO);
        }
    }
 
    if (partner != NULL) {
        if (partner->koDuration < partner->debuffDuration) {
            partner->koStatus = STATUS_KEY_DAZE;
            partner->koDuration = partner->debuffDuration;
        }
 
        if (partner->koDuration > 0) {
            partner->koStatus = STATUS_KEY_DAZE;
            partner->disableEffect->data.disableX->koDuration = partner->koDuration;
        }
    }
 
    for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
        Actor* enemy = battleStatus->enemyActors[i];
 
        if (enemy != NULL) {
            enemy->koDuration = enemy->debuffDuration;
            if (enemy->koDuration > 0) {
                enemy->koStatus = STATUS_KEY_DAZE;
                enemy->disableEffect->data.disableX->koDuration = enemy->koDuration;
            }
        }
    }
}

Referenced by btl_state_update_enemy_move(), btl_state_update_partner_move(), and btl_state_update_player_move().

◆ reset_actor_turn_info()

void reset_actor_turn_info ( void )

Definition at line 978 of file 190B20.c.

                                 {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* actor;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
        actor = battleStatus->enemyActors[i];
        if (actor != NULL) {
            actor->hpChangeCounter = 0;
            actor->damageCounter = 0;
            actor->actionRatingCombo = 0;
        }
 
    }
    actor = battleStatus->playerActor;
    actor->hpChangeCounter = 0;
    actor->damageCounter = 0;
    actor->actionRatingCombo = 0;
 
    actor = battleStatus->partnerActor;
    if (actor != NULL) {
        actor->hpChangeCounter = 0;
        actor->damageCounter = 0;
        actor->actionRatingCombo = 0;
    }
}

Referenced by btl_state_update_9(), btl_state_update_begin_partner_turn(), btl_state_update_begin_player_turn(), btl_state_update_enemy_move(), btl_state_update_enemy_striking_first(), btl_state_update_first_strike(), btl_state_update_partner_move(), btl_state_update_partner_striking_first(), btl_state_update_player_move(), btl_state_update_switch_to_partner(), and btl_state_update_switch_to_player().

◆ startup_draw_prim_rect()

void startup_draw_prim_rect	(	s16	left,
		s16	top,
		s16	right,
		s16	bottom,
		u16	r,
		u16	g,
		u16	b,
		u16	a )

Definition at line 822 of file 43F0.c.

                                                                                                  {
    u16 temp;
 
    if (right < left) {
        temp = right;
        right = left;
        left = temp;
    }
 
    if (bottom < top) {
        temp = bottom;
        bottom = top;
        top = temp;
    }
 
    appendGfx_startup_prim_rect(r, g, b, a, left, top, right, bottom);
}

Referenced by state_drawUI_startup().

◆ startup_draw_prim_rect_COPY()

void startup_draw_prim_rect_COPY	(	s16	left,
		s16	top,
		s16	right,
		s16	bottom,
		u16	r,
		u16	g,
		u16	b,
		u16	a )

Definition at line 804 of file 43F0.c.

                                                                                                       {
    u16 temp;
 
    if (right < left) {
        temp = right;
        right = left;
        left = temp;
    }
 
    if (bottom < top) {
        temp = bottom;
        bottom = top;
        top = temp;
    }
 
    appendGfx_startup_prim_rect(r, g, b, a, left, top, right, bottom);
}

Referenced by draw_mash_meter().

◆ btl_draw_prim_quad()

void btl_draw_prim_quad	(	u8	r,
		u8	g,
		u8	b,
		u8	a,
		u16	left,
		u16	top,
		u16	arg6,
		u16	arg7 )

Definition at line 2931 of file 190B20.c.

                                                                                       {
    u16 right = left + arg6;
    u16 bottom = top + arg7;
 
    btl_appendGfx_prim_quad(r, g, b, a, left, top, right, bottom);
}

Referenced by btl_draw_enemy_health_bars(), and btl_main_menu_draw().

◆ reset_all_actor_sounds()

void reset_all_actor_sounds ( Actor * actor )

Definition at line 2938 of file 190B20.c.

                                          {
    ActorPart* partIt = &actor->partsTable[0];
 
    actor->actorTypeData1[0] = bActorSoundTable[actor->actorType].walk[0];
    actor->actorTypeData1[1] = bActorSoundTable[actor->actorType].walk[1];
    actor->actorTypeData1[2] = bActorSoundTable[actor->actorType].fly[0];
    actor->actorTypeData1[3] = bActorSoundTable[actor->actorType].fly[1];
    actor->actorTypeData1[4] = bActorSoundTable[actor->actorType].jump;
    actor->actorTypeData1[5] = bActorSoundTable[actor->actorType].hurt;
    actor->actorTypeData1b[0] = bActorSoundTable[actor->actorType].delay[0];
    actor->actorTypeData1b[1] = bActorSoundTable[actor->actorType].delay[1];
 
    while (partIt != NULL) {
        partIt->partTypeData[0] = actor->actorTypeData1[0];
        partIt->partTypeData[1] = actor->actorTypeData1[1];
        partIt->partTypeData[2] = actor->actorTypeData1[2];
        partIt->partTypeData[3] = actor->actorTypeData1[3];
        partIt->partTypeData[4] = actor->actorTypeData1[4];
        partIt->partTypeData[5] = actor->actorTypeData1[5];
        partIt->actorTypeData2b[0] = actor->actorTypeData1b[0];
        partIt->actorTypeData2b[1] = actor->actorTypeData1b[1];
        partIt = partIt->nextPart;
    }
}

Referenced by btl_state_update_enemy_move(), btl_state_update_partner_move(), and btl_state_update_player_move().

◆ decrement_status_bar_disabled()

void decrement_status_bar_disabled ( void )

Definition at line 1657 of file inventory.c.

                                         {
    StatusBar* statusBar = &gStatusBar;
 
    if (statusBar->disabled > 0) {
        statusBar->disabled--;
    }
}

Referenced by btl_state_update_end_battle(), btl_state_update_end_demo_battle(), btl_state_update_first_strike(), btl_state_update_partner_move(), btl_state_update_partner_striking_first(), btl_state_update_player_move(), and update_item_entity_pickup().

◆ increment_status_bar_disabled()

void increment_status_bar_disabled ( void )

Definition at line 1665 of file inventory.c.

                                         {
    StatusBar* statusBar = &gStatusBar;
 
    statusBar->disabled++;
}

Referenced by btl_state_update_first_strike(), btl_state_update_partner_move(), btl_state_update_partner_striking_first(), btl_state_update_player_move(), initialize_battle(), and update_item_entity_pickup().

◆ btl_delete_actor()

void btl_delete_actor ( Actor * actor )

Definition at line 1110 of file 16C8E0.c.

                                    {
    ActorPart* part;
    ActorPart* actorPartTemp;
    BattleStatus* battleStatus;
    s32 i;
 
    // TODO hard-coded
    for (i = 0; i < 2; i++) {
        remove_actor_decoration(actor, i);
    }
    if (actor->idleScript != NULL) {
        kill_script_by_ID(actor->idleScriptID);
    }
    if (actor->handleEventScript != NULL) {
        kill_script_by_ID(actor->handleEventScriptID);
    }
    if (actor->takeTurnScript != NULL) {
        kill_script_by_ID(actor->takeTurnScriptID);
    }
    set_actor_glow_pal(actor, GLOW_PAL_OFF);
 
    part = actor->partsTable;
 
    while (part != NULL) {
        if (!(part->flags & ACTOR_PART_FLAG_NO_SHADOW)) {
            delete_shadow(part->shadowIndex);
        }
 
        if (part->idleAnimations != NULL) {
            set_npc_imgfx_all(part->spriteInstanceID, IMGFX_CLEAR, 0, 0, 0, 0, 0);
 
            ASSERT(spr_free_sprite(part->spriteInstanceID) == 0);
 
            if (!(part->flags & ACTOR_PART_FLAG_SKIP_MOVEMENT_ALLOC)) {
                heap_free(part->movement);
            }
 
            if (!(part->flags & ACTOR_PART_FLAG_NO_DECORATIONS)) {
                heap_free(part->decorationTable);
            }
        }
        actorPartTemp = part->nextPart;
        heap_free(part);
        part = actorPartTemp;
    }
 
    delete_shadow(actor->shadow.id);
    remove_all_status_icons(actor->hudElementDataIndex);
    remove_effect(actor->disableEffect);
 
    if (actor->attackResultEffect != NULL) {
        actor->attackResultEffect->data.attackResultText->isVisible = FALSE;
    }
 
    battleStatus = &gBattleStatus;
    for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
        if (battleStatus->enemyActors[i] == actor) {
            battleStatus->enemyActors[i] = NULL;
            break;
        }
    }
 
    heap_free(actor);
}

Referenced by btl_state_update_change_partner(), btl_state_update_end_battle(), and btl_state_update_end_demo_battle().

◆ create_status_debuff()

void create_status_debuff	(	s32	iconID,
		s32	statusID )

Definition at line 1054 of file status_icons.c.

                                                    {
    HudStatusIcon* statusIcon = &D_800A0F44[iconID];
 
    statusIcon->flags &= ~STATUS_ICON_FLAG_DEBUFF;
    if (statusIcon->status1.active != statusID) {
        remove_status_debuff(iconID);
        statusIcon->status1.active = statusID;
        statusIcon->status1.activeTask = STATUS_ICON_TASK_LOAD;
    }
}

Referenced by appendGfx_npc_actor(), appendGfx_player_actor(), and inflict_status().

◆ create_status_static()

void create_status_static	(	s32	iconID,
		s32	statusID )

Definition at line 1084 of file status_icons.c.

                                                    {
    HudStatusIcon* statusIcon = &D_800A0F44[iconID];
 
    statusIcon->flags &= ~STATUS_ICON_FLAG_STATIC;
    if (statusIcon->status2.active != statusID) {
        remove_status_static(iconID);
        statusIcon->status2.active = statusID;
        statusIcon->status2.activeTask = 1;
    }
}

Referenced by appendGfx_npc_actor(), appendGfx_player_actor(), and inflict_status().

◆ create_status_transparent()

void create_status_transparent	(	s32	iconID,
		s32	statusID )

Definition at line 1114 of file status_icons.c.

                                                         {
    HudStatusIcon* statusIcon = &D_800A0F44[iconID];
 
    statusIcon->flags &= ~STATUS_ICON_FLAG_TRANSPARENT;
    if (statusIcon->status3.active != statusID) {
        remove_status_transparent(iconID);
        statusIcon->status3.active = statusID;
        statusIcon->status3.activeTask = 1;
    }
}

Referenced by appendGfx_npc_actor(), appendGfx_player_actor(), and inflict_status().

◆ remove_status_chill_out()

void remove_status_chill_out ( s32 iconID )

Definition at line 1154 of file status_icons.c.

                                         {
    HudStatusIcon* statusIcon = &D_800A0F44[iconID];
 
    if (statusIcon->status4.active && !statusIcon->status4.removing) {
        statusIcon->status4.removing = statusIcon->status4.active;
        statusIcon->status4.removingTask = TRUE;
        statusIcon->status4.active = FALSE;
        statusIcon->status4.activeTask = FALSE;
        statusIcon->status4.frameCounter = 10;
        statusIcon->status4.removingElementHID = statusIcon->status4.activeElementHID;
    }
}

Referenced by btl_state_update_begin_player_turn(), and remove_all_status_icons().

◆ remove_status_debuff()

void remove_status_debuff ( s32 iconID )

Definition at line 1065 of file status_icons.c.

                                      {
    HudStatusIcon* statusIcon = &D_800A0F44[iconID];
 
    if (statusIcon->status1.active && !statusIcon->status1.removing) {
        statusIcon->status1.removing = statusIcon->status1.active;
        statusIcon->status1.removingTask = STATUS_ICON_TASK_LOAD;
        statusIcon->status1.active = 0;
        statusIcon->status1.activeTask = STATUS_ICON_TASK_NONE;
        statusIcon->status1.frameCounter = 10;
        statusIcon->status1.removingElementHID = statusIcon->status1.activeElementHID;
    }
}

Referenced by btl_state_update_9(), btl_state_update_begin_player_turn(), btl_state_update_defeat(), create_status_debuff(), and remove_all_status_icons().

◆ remove_status_icon_boost_hammer()

void remove_status_icon_boost_hammer ( s32 iconID )

Definition at line 1219 of file status_icons.c.

                                                 {
    HudStatusIcon* statusIcon = &D_800A0F44[iconID];
 
    if (statusIcon->boostHammer.active) {
        HudElemID hid = statusIcon->boostHammer.activeElementID;
        statusIcon->boostHammer.active = FALSE;
        statusIcon->boostHammer.removing = FALSE;
        statusIcon->prevIndexBoostHammer = hid;
        hud_element_set_script(hid, &HES_BoostHammerEnd);
    }
}

Referenced by appendGfx_player_actor(), and remove_all_status_icons().

◆ remove_status_icon_boost_jump()

void remove_status_icon_boost_jump ( s32 iconID )

Definition at line 1187 of file status_icons.c.

                                               {
    HudStatusIcon* statusIcon = &D_800A0F44[iconID];
 
    if (statusIcon->boostJump.active) {
        HudElemID hid = statusIcon->boostJump.activeElementID;
        statusIcon->boostJump.active = FALSE;
        statusIcon->boostJump.removing = TRUE;
        statusIcon->prevIndexBoostJump = hid;
        hud_element_set_script(hid, &HES_BoostJumpEnd);
    }
}

Referenced by appendGfx_player_actor(), and remove_all_status_icons().

◆ remove_status_icon_boost_partner()

void remove_status_icon_boost_partner ( s32 iconID )

Definition at line 1251 of file status_icons.c.

                                                  {
    HudStatusIcon* statusIcon = &D_800A0F44[iconID];
 
    if (statusIcon->boostPartner.active) {
        statusIcon->boostPartner.active = FALSE;
        hud_element_free(statusIcon->boostPartner.activeElementID);
    }
}

Referenced by remove_all_status_icons().

◆ remove_status_icon_danger()

void remove_status_icon_danger ( s32 iconID )

Definition at line 1338 of file status_icons.c.

                                           {
    HudStatusIcon* statusIcon = &D_800A0F44[iconID];
 
    if (statusIcon->danger.active) {
        statusIcon->danger.active = FALSE;
        hud_element_free(statusIcon->danger.activeElementID);
    }
}

Referenced by appendGfx_player_actor(), and remove_all_status_icons().

◆ remove_status_icon_peril()

void remove_status_icon_peril ( s32 iconID )

Definition at line 1309 of file status_icons.c.

                                          {
    HudStatusIcon* statusIcon = &D_800A0F44[iconID];
 
    if (statusIcon->peril.active) {
        statusIcon->peril.active = FALSE;
        hud_element_free(statusIcon->peril.activeElementID);
    }
}

Referenced by appendGfx_player_actor(), and remove_all_status_icons().

◆ remove_status_icon_surprise()

void remove_status_icon_surprise ( s32 iconID )

Definition at line 1280 of file status_icons.c.

                                             {
    HudStatusIcon* statusIcon = &D_800A0F44[iconID];
 
    if (statusIcon->surprise.active) {
        statusIcon->surprise.active = FALSE;
        hud_element_free(statusIcon->surprise.activeElementID);
    }
}

Referenced by remove_all_status_icons().

◆ remove_status_static()

void remove_status_static ( s32 iconID )

Definition at line 1095 of file status_icons.c.

                                      {
    HudStatusIcon* statusIcon = &D_800A0F44[iconID];
 
    if (statusIcon->status2.active && !statusIcon->status2.removing) {
        statusIcon->status2.removing = statusIcon->status2.active;
        statusIcon->status2.removingTask = TRUE;
        statusIcon->status2.active = FALSE;
        statusIcon->status2.activeTask = FALSE;
        statusIcon->status2.frameCounter = 10;
        statusIcon->status2.removingElementHID = statusIcon->status2.activeElementHID;
    }
}

Referenced by btl_state_update_9(), btl_state_update_begin_player_turn(), calc_item_damage_enemy(), create_status_static(), remove_all_status_icons(), and remove_player_buffs().

◆ remove_status_transparent()

void remove_status_transparent ( s32 iconID )

Definition at line 1125 of file status_icons.c.

                                           {
    HudStatusIcon* statusIcon = &D_800A0F44[iconID];
 
    if (statusIcon->status3.active && !statusIcon->status3.removing) {
        statusIcon->status3.removing = statusIcon->status3.active;
        statusIcon->status3.removingTask = TRUE;
        statusIcon->status3.active = FALSE;
        statusIcon->status3.activeTask = FALSE;
        statusIcon->status3.frameCounter = 10;
        statusIcon->status3.removingElementHID = statusIcon->status3.activeElementHID;
    }
}

Referenced by btl_state_update_9(), btl_state_update_begin_player_turn(), calc_item_damage_enemy(), create_status_transparent(), remove_all_status_icons(), and remove_player_buffs().

◆ remove_all_status_icons()

void remove_all_status_icons ( s32 iconID )

Definition at line 1015 of file status_icons.c.

                                         {
    HudStatusIcon* statusIcon = &D_800A0F44[iconID];
 
    remove_status_debuff(iconID);
    remove_status_static(iconID);
    remove_status_transparent(iconID);
    remove_status_chill_out(iconID);
    remove_status_icon_boost_jump(iconID);
    remove_status_icon_boost_hammer(iconID);
    remove_status_icon_boost_partner(iconID);
    remove_status_icon_surprise(iconID);
    remove_status_icon_peril(iconID);
    remove_status_icon_danger(iconID);
    statusIcon->flags = 0;
}

Referenced by btl_delete_actor(), and btl_delete_player_actor().

◆ create_status_icon_set()

s32 create_status_icon_set ( void )

Definition at line 957 of file status_icons.c.

                                 {
    s32 i;
    HudStatusIcon* icon;
 
    for (icon = D_800A0F44, i = 0; i < MAX_ICONS; icon++, i++) {
        if (icon->flags == 0) {
            break;
        }
    }
 
    ASSERT(i < MAX_ICONS);
 
    icon->flags = STATUS_ICON_FLAG_USED;
 
    if (gGameStatusPtr->context != CONTEXT_WORLD) {
        icon->flags |= STATUS_ICON_FLAG_BATTLE;
    }
 
    icon->worldPos.x = 0;
    icon->worldPos.y = 0;
    icon->worldPos.z = 0;
 
    icon->status1Radius = 0;
    icon->status1OffsetY = 0;
    icon->status2Radius = 0;
    icon->status2OffsetY = 0;
    icon->status3Radius = 0;
    icon->status3OffsetY = 0;
    icon->status4Radius = 0;
    icon->status4OffsetY = 0;
    icon->status1.active = 0;
    icon->status1.removing = 0;
    icon->status1.activeTask = 0;
    icon->status1.removingTask = 0;
    icon->status2.active = 0;
    icon->status2.removing = 0;
    icon->status2.activeTask = 0;
    icon->status2.removingTask = 0;
    icon->status3.active = 0;
    icon->status3.removing = 0;
    icon->status3.activeTask = 0;
    icon->status3.removingTask = 0;
    icon->status4.active = 0;
    icon->status4.removing = 0;
    icon->status4.activeTask = 0;
    icon->status4.removingTask = 0;
    icon->boostJump.active = 0;
    icon->boostJump.removing = 0;
    icon->boostHammer.active = 0;
    icon->boostHammer.removing = 0;
    icon->boostPartner.active = 0;
    icon->surprise.active = 0;
    icon->peril.active = 0;
    icon->danger.active = 0;
 
    return i;
}

Referenced by create_actor(), load_partner_actor(), and load_player_actor().

◆ find_item()

s32 find_item ( s32 itemID )

Search player inventory for itemID and return first matching array index.

Returns: the index of the given item in the player's inventory, or -1 if not found

Definition at line 264 of file inventory.c.

                          {
    s32 idx;
 
    // handle key items
    if (item_is_key(itemID)) {
        for (idx = 0; idx < ARRAY_COUNT(gPlayerData.keyItems); idx++) {
            if (gPlayerData.keyItems[idx] == itemID) {
                break;
            }
        }
 
        if (idx >= ARRAY_COUNT(gPlayerData.keyItems)) {
            return -1;
        }
        return idx;
    }
 
    // handle badges
    if (item_is_badge(itemID)) {
        for (idx = 0; idx < ARRAY_COUNT(gPlayerData.badges); idx++) {
            if (gPlayerData.badges[idx] == itemID) {
                break;
            }
        }
 
        if (idx >= ARRAY_COUNT(gPlayerData.badges)) {
            return -1;
        }
        return idx;
    }
 
    // handle consumables
    for (idx = 0; idx < ARRAY_COUNT(gPlayerData.invItems); idx++) {
        if (gPlayerData.invItems[idx] == itemID) {
            break;
        }
    }
 
    if (idx == ARRAY_COUNT(gPlayerData.invItems)) {
        return -1;
    }
    return idx;
}

Referenced by btl_state_update_defeat().

◆ enable_background_wave()

void enable_background_wave ( void )

Definition at line 309 of file background.c.

                                  {
    gBackroundWaveEnabled = TRUE;
}

Referenced by EnableBackgroundWave().

◆ set_map_change_fade_rate()

void set_map_change_fade_rate ( s16 fadeRate )

Definition at line 11 of file state_map_transitions.c.

                                            {
    gMapTransitionFadeRate = fadeRate;
}

◆ load_map_by_IDs()

void load_map_by_IDs	(	s16	areaID,
		s16	mapID,
		s16	loadType )

Definition at line 53 of file world.c.

                                                          {
    s32 skipLoadingAssets = 0;
    MapConfig* mapConfig;
    MapSettings* mapSettings;
    char texStr[17];
    s32 decompressedSize;
 
    sfx_stop_env_sounds();
    gOverrideFlags &= ~GLOBAL_OVERRIDES_40;
    gOverrideFlags &= ~GLOBAL_OVERRIDES_ENABLE_FLOOR_REFLECTION;
 
    gGameStatusPtr->playerSpriteSet = PLAYER_SPRITES_MARIO_WORLD;
    surface_set_walk_effect(SURFACE_WALK_FX_STANDARD);
    phys_set_player_sliding_check(NULL);
    phys_set_landing_adjust_cam_check(NULL);
 
#if !VERSION_IQUE
    load_obfuscation_shims();
#endif
    shim_general_heap_create_obfuscated();
 
#if VERSION_JP
    reset_max_rumble_duration();
#endif
    clear_render_tasks();
    clear_worker_list();
    clear_script_list();
 
    switch (loadType) {
        case LOAD_FROM_MAP:
            clear_area_flags();
            gGameStatusPtr->loadType = LOAD_FROM_MAP;
            break;
        case LOAD_FROM_FILE_SELECT:
            fio_deserialize_state();
            areaID = gGameStatusPtr->areaID;
            mapID = gGameStatusPtr->mapID;
            gGameStatusPtr->prevArea = areaID;
            gGameStatusPtr->loadType = LOAD_FROM_FILE_SELECT;
            break;
    }
 
    gGameStatusPtr->mapShop = NULL;
 
    ASSERT_MSG(areaID < ARRAY_COUNT(gAreas) - 1, "Invalid area ID %d", areaID);
    ASSERT_MSG(mapID < gAreas[areaID].mapCount, "Invalid map ID %d in %s", mapID, gAreas[areaID].id);
    mapConfig = &gAreas[areaID].maps[mapID];
 
    #if DX_DEBUG_MENU
    dx_debug_set_map_info(mapConfig->id, gGameStatus.entryID);
    #endif
 
    sprintf(wMapShapeName, "%s_shape", mapConfig->id);
    sprintf(wMapHitName, "%s_hit", mapConfig->id);
    strcpy(texStr, mapConfig->id);
    texStr[3] = '\0';
    sprintf(wMapTexName, "%s_tex", texStr);
 
    gMapConfig = mapConfig;
    if (mapConfig->bgName != NULL) {
        strcpy(wMapBgName, mapConfig->bgName);
    }
    load_map_script_lib();
 
    if (mapConfig->dmaStart != NULL) {
        dma_copy(mapConfig->dmaStart, mapConfig->dmaEnd, mapConfig->dmaDest);
    }
 
    gMapSettings = *mapConfig->settings;
 
    mapSettings = &gMapSettings;
    if (mapConfig->init != NULL) {
        skipLoadingAssets = mapConfig->init();
    }
 
    if (!skipLoadingAssets) {
        ShapeFile* shapeFile = &gMapShapeData;
        void* yay0Asset = load_asset_by_name(wMapShapeName, &decompressedSize);
 
        decode_yay0(yay0Asset, shapeFile);
        general_heap_free(yay0Asset);
 
        mapSettings->modelTreeRoot = shapeFile->header.root;
        mapSettings->modelNameList = shapeFile->header.modelNames;
        mapSettings->colliderNameList = shapeFile->header.colliderNames;
        mapSettings->zoneNameList = shapeFile->header.zoneNames;
    }
 
    if (mapConfig->bgName != NULL) {
        load_map_bg(wMapBgName);
    }
 
#if !VERSION_IQUE
    load_obfuscation_shims();
#endif
    shim_general_heap_create_obfuscated();
 
    sfx_clear_env_sounds(0);
    clear_worker_list();
    clear_script_list();
    create_cameras();
    spr_init_sprites(gGameStatusPtr->playerSpriteSet);
    clear_animator_list();
    clear_entity_models();
    clear_npcs();
    hud_element_clear_cache();
    clear_trigger_data();
    clear_model_data();
    clear_sprite_shading_data();
    reset_background_settings();
 
    if (gGameStatusPtr->introPart == INTRO_PART_NONE) {
        func_80138188();
    }
 
    if (!skipLoadingAssets) {
        initialize_collision();
        load_map_hit_asset();
    }
 
    reset_battle_status();
    clear_encounter_status();
    clear_entity_data(TRUE);
    clear_effect_data();
    clear_player_status();
    player_reset_data();
    partner_reset_data();
    clear_printers();
    clear_item_entity_data();
 
    gPlayerStatus.targetYaw = gPlayerStatus.curYaw;
 
    sfx_set_reverb_mode(WorldReverbModeMapping[*(s32*)mapConfig->unk_1C & 0x3]);
    sfx_reset_door_sounds();
 
    if (!skipLoadingAssets) {
        s32 texturesOffset = get_asset_offset(wMapTexName, &decompressedSize);
 
        if (mapSettings->modelTreeRoot != NULL) {
            load_data_for_models(mapSettings->modelTreeRoot, texturesOffset, decompressedSize);
        }
    }
 
    if (mapSettings->background != NULL) {
        set_background(mapSettings->background);
    } else {
        set_background_size(296, 200, 12, 20);
    }
 
    gCurrentCameraID = CAM_DEFAULT;
    gCameras[CAM_DEFAULT].flags |= CAMERA_FLAG_DISABLED;
    gCameras[CAM_BATTLE].flags |= CAMERA_FLAG_DISABLED;
    gCameras[CAM_TATTLE].flags |= CAMERA_FLAG_DISABLED;
    gCameras[CAM_HUD].flags |= CAMERA_FLAG_DISABLED;
 
    if (gGameStatusPtr->introPart == INTRO_PART_NONE) {
        set_cam_viewport(CAM_DEFAULT, 12, 20, 296, 200);
    } else {
        set_cam_viewport(CAM_DEFAULT, 29, 28, 262, 162);
    }
 
    initialize_status_bar();
    gGameStatusPtr->unk_90 = 1000;
    gGameStatusPtr->unk_92 = 1000;
    gGameStatusPtr->mainScriptID = start_script_in_group(mapSettings->main, EVT_PRIORITY_0, 0, EVT_GROUP_NEVER_PAUSE)->id;
}

Referenced by state_step_change_map(), state_step_enter_world(), state_step_game_over(), and state_step_intro().

◆ state_init_startup()

void state_init_startup ( void )

Definition at line 9 of file state_startup.c.

                              {
    gOverrideFlags |= GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
    gGameStatus.startupState = 3;
}

◆ state_step_startup()

void state_step_startup ( void )

Definition at line 14 of file state_startup.c.

                              {
    s32 i;
 
    if (gGameStatus.startupState != 0) {
        gGameStatus.startupState--;
        return;
    }
 
    gOverrideFlags = 0;
    gGameStatus.areaID = 0;
    gGameStatus.context = CONTEXT_WORLD;
    gGameStatus.prevArea = -1;
    gGameStatus.mapID = 0;
    gGameStatus.entryID = 0;
    gGameStatus.debugUnused1 = FALSE;
    gGameStatus.debugScripts = DEBUG_SCRIPTS_NONE;
    gGameStatus.keepUsingPartnerOnMapChange = FALSE;
    gGameStatus.introPart = INTRO_PART_NONE;
    gGameStatus.demoBattleFlags = 0;
    gGameStatus.unk_A9 = -1;
    gGameStatus.demoState = DEMO_STATE_NONE;
 
    general_heap_create();
    clear_render_tasks();
    clear_worker_list();
    clear_script_list();
    create_cameras();
    spr_init_sprites(PLAYER_SPRITES_MARIO_WORLD);
    clear_entity_models();
    clear_animator_list();
    clear_model_data();
    clear_sprite_shading_data();
    reset_background_settings();
    hud_element_set_aux_cache(0, 0);
    hud_element_clear_cache();
    clear_trigger_data();
    clear_printers();
    clear_entity_data(FALSE);
    clear_screen_overlays();
    clear_player_status();
    clear_npcs();
    clear_player_data();
    reset_battle_status();
    init_encounter_status();
    clear_effect_data();
    clear_item_entity_data();
    clear_saved_variables();
    initialize_collision();
    bgm_init_music_players();
    clear_windows();
    partner_initialize_data();
    sfx_clear_sounds();
    bgm_reset_volume();
    initialize_curtains();
 
    for (i = 0; i < ARRAY_COUNT(gGameStatus.unk_50); i++) {
        gGameStatus.unk_50[i] = 4;
        gGameStatus.unk_48[i] = 15;
    }
 
    fio_load_globals();
 
    if (gSaveGlobals.useMonoSound == 0) {
        gGameStatus.soundOutputMode = SOUND_OUT_STEREO;
        audio_set_stereo();
    } else {
        gGameStatus.soundOutputMode = SOUND_OUT_MONO;
        audio_set_mono();
    }
 
    gOverrideFlags &= ~GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
 
    #if DX_QUICK_LAUNCH
        // immediately jump into the world using last-used save file
        gGameStatus.saveSlot = gSaveGlobals.lastFileSelected;
        if (fio_load_game(gGameStatusPtr->saveSlot)) {
            set_game_mode(GAME_MODE_ENTER_WORLD);
            gOverrideFlags &= ~GLOBAL_OVERRIDES_DISABLE_RENDER_WORLD;
            return;
        }
    #endif
 
    #if DX_SKIP_LOGOS
        // go right to the story book or file select
        #if DX_SKIP_STORY
            set_curtain_scale(1.0f);
            set_curtain_fade(0.0f);
            set_game_mode(GAME_MODE_TITLE_SCREEN);
        #else
            set_curtain_scale(1.0f);
            set_curtain_fade(0.3f);
            gGameStatus.introPart = INTRO_PART_0;
            set_game_mode(GAME_MODE_INTRO);
        #endif
    #else
        // use vanilla startup process
        set_game_mode(GAME_MODE_LOGOS);
    #endif
}

◆ state_drawUI_startup()

void state_drawUI_startup ( void )

Definition at line 114 of file state_startup.c.

                                {
    startup_draw_prim_rect(0, 0, SCREEN_WIDTH - 1, SCREEN_HEIGHT - 1, 0, 0, 0, 255);
}

◆ state_init_logos()

void state_init_logos ( void )

Definition at line 66 of file state_logos.c.

                            {
    s8* romStart;
    s8* romEnd;
 
    general_heap_create();
    gGameStatusPtr->startupState = LOGOS_STATE_N64_FADE_IN;
    gGameStatusPtr->logoTime = 0;
    gGameStatusPtr->skipLogos = FALSE;
    startup_set_fade_screen_alpha(255);
    startup_set_fade_screen_color(0);
 
    romEnd = logos_ROM_END;
    romStart = logos_ROM_START;
    gLogosImages = heap_malloc(romEnd - romStart);
    dma_copy(romStart, romEnd, gLogosImages);
 
    gLogosImage1 = gLogosImages + 0x0;
    gLogosImage3 = gLogosImages + 0x7000;
    gLogosImage2 = gLogosImages + 0x15000;
 
    nuContRmbForceStop();
    create_cameras();
    gCameras[CAM_DEFAULT].updateMode = CAM_UPDATE_NO_INTERP;
    gCameras[CAM_DEFAULT].needsInit = TRUE;
    gCameras[CAM_DEFAULT].nearClip = CAM_NEAR_CLIP;
    gCameras[CAM_DEFAULT].farClip = CAM_FAR_CLIP;
    gCameras[CAM_DEFAULT].vfov = 25.0f;
    set_cam_viewport(CAM_DEFAULT, 12, 28, 296, 184);
 
    gCameras[CAM_DEFAULT].params.basic.skipRecalc = FALSE;
    gCameras[CAM_DEFAULT].params.basic.pitch = 0;
    gCameras[CAM_DEFAULT].params.basic.dist = 40;
    gCameras[CAM_DEFAULT].params.basic.fovScale = 100;
 
    gCameras[CAM_DEFAULT].lookAt_eye.x = 500.0f;
    gCameras[CAM_DEFAULT].lookAt_eye.y = 1000.0f;
    gCameras[CAM_DEFAULT].lookAt_eye.z = 1500.0f;
 
    gCameras[CAM_DEFAULT].lookAt_obj_target.x = 25.0f;
    gCameras[CAM_DEFAULT].lookAt_obj_target.y = 25.0f;
    gCameras[CAM_DEFAULT].lookAt_obj_target.z = 150.0f;
 
    gCameras[CAM_DEFAULT].bgColor[0] = 0;
    gCameras[CAM_DEFAULT].bgColor[1] = 0;
    gCameras[CAM_DEFAULT].bgColor[2] = 0;
 
    gCurrentCameraID = CAM_DEFAULT;
 
    gCameras[CAM_DEFAULT].flags |= CAMERA_FLAG_DISABLED;
    gCameras[CAM_BATTLE].flags |= CAMERA_FLAG_DISABLED;
    gCameras[CAM_TATTLE].flags |= CAMERA_FLAG_DISABLED;
    gCameras[CAM_HUD].flags |= CAMERA_FLAG_DISABLED;
 
    clear_script_list();
    clear_worker_list();
    clear_render_tasks();
    spr_init_sprites(PLAYER_SPRITES_MARIO_WORLD);
    clear_animator_list();
    clear_entity_models();
    clear_npcs();
    hud_element_clear_cache();
    reset_background_settings();
    clear_entity_data(TRUE);
    clear_effect_data();
    gOverrideFlags |= GLOBAL_OVERRIDES_DISABLE_RENDER_WORLD;
    startup_fade_screen_update();
    gGameStatusPtr->backgroundFlags = 0;
}

◆ state_step_logos()

void state_step_logos ( void )

Definition at line 135 of file state_logos.c.

                            {
    int pressedButtons = gGameStatusPtr->pressedButtons[0];
    if (gGameStatusPtr->skipLogos) {
        if (startup_fade_screen_out(10)) {
            set_curtain_scale(1.0f);
            set_curtain_fade(0.0f);
            set_game_mode(GAME_MODE_TITLE_SCREEN);
        }
    } else {
        if ((gGameStatusPtr->startupState == LOGOS_STATE_N64_HOLD
            || gGameStatusPtr->startupState == LOGOS_STATE_N64_FADE_OUT
            || gGameStatusPtr->startupState == LOGOS_STATE_NINTENDO_FADE_IN
            || gGameStatusPtr->startupState == LOGOS_STATE_NINTENDO_HOLD
            || gGameStatusPtr->startupState == LOGOS_STATE_NINTENDO_FADE_OUT
            || gGameStatusPtr->startupState == LOGOS_STATE_IS_FADE_IN
            || gGameStatusPtr->startupState == LOGOS_STATE_IS_HOLD_1
            || gGameStatusPtr->startupState == LOGOS_STATE_IS_HOLD_2
            || gGameStatusPtr->startupState == LOGOS_STATE_IS_FADE_OUT
            || gGameStatusPtr->startupState == LOGOS_STATE_CURTAINS_APPEAR)
            && (pressedButtons & (BUTTON_START | BUTTON_Z | BUTTON_A))
        ) {
            startup_set_fade_screen_color(208);
            gGameStatusPtr->skipLogos = TRUE;
        }
 
        switch (gGameStatusPtr->startupState) {
            case LOGOS_STATE_N64_FADE_IN:
                if (startup_fade_screen_in(10)) {
                    gGameStatusPtr->startupState++;
                    gGameStatusPtr->logoTime = 30;
                }
                break;
            case LOGOS_STATE_N64_HOLD:
                if (gGameStatusPtr->logoTime == 0) {
                    startup_set_fade_screen_color(208);
                    gGameStatusPtr->startupState++;
                }
                gGameStatusPtr->logoTime--;
                break;
            case LOGOS_STATE_N64_FADE_OUT:
                if (startup_fade_screen_out(10)) {
                    gGameStatusPtr->startupState++;
#if VERSION_JP
                    gGameStatusPtr->startupState += 2;
#endif
                }
                break;
            case LOGOS_STATE_NINTENDO_FADE_IN:
                if (startup_fade_screen_in(10)) {
                    gGameStatusPtr->startupState++;
                    gGameStatusPtr->logoTime = N64_FADE_IN_TIME;
                }
                break;
            case LOGOS_STATE_NINTENDO_HOLD:
                if (gGameStatusPtr->logoTime == 0) {
                    gGameStatusPtr->startupState++;
#if VERSION_JP
                    startup_set_fade_screen_color(0);
#else
                    startup_set_fade_screen_color(208);
#endif
                }
                gGameStatusPtr->logoTime--;
                break;
            case LOGOS_STATE_NINTENDO_FADE_OUT:
                if (startup_fade_screen_out(10)) {
                    gGameStatusPtr->startupState++;
                }
                break;
            case LOGOS_STATE_IS_FADE_IN:
                if (startup_fade_screen_in(10)) {
                    gGameStatusPtr->startupState++;
                    gGameStatusPtr->logoTime = 30;
                }
                break;
            case LOGOS_STATE_IS_HOLD_1:
                if (gGameStatusPtr->logoTime == 0) {
                    gGameStatusPtr->startupState++;
                    startup_set_fade_screen_color(208);
                    gGameStatusPtr->logoTime = 30;
                }
                gGameStatusPtr->logoTime--;
                break;
            case LOGOS_STATE_IS_HOLD_2:
                if (gGameStatusPtr->logoTime == 0) {
                    gGameStatusPtr->startupState++;
                    set_curtain_scale_goal(1.0f);
                    set_curtain_draw_callback(NULL);
                    set_curtain_fade_goal(0.3f);
                } else {
                    gGameStatusPtr->logoTime--;
                }
                break;
            case LOGOS_STATE_IS_FADE_OUT:
                if (startup_fade_screen_out(10)) {
                    gGameStatusPtr->logoTime = 15;
                    gGameStatusPtr->startupState++;
                }
                break;
            case LOGOS_STATE_CURTAINS_APPEAR:
                if (gGameStatusPtr->logoTime == 0) {
                    gGameStatusPtr->startupState++;
                } else {
                    gGameStatusPtr->logoTime--;
                }
                break;
            case LOGOS_STATE_CLEANUP:
                heap_free(gLogosImages);
                gLogosImages = NULL;
                startup_set_fade_screen_alpha(255);
                gGameStatusPtr->introPart = INTRO_PART_0;
                set_game_mode(GAME_MODE_INTRO);
                break;
        }
    }
    update_npcs();
    update_cameras();
    startup_fade_screen_update();
}

◆ state_drawUI_logos()

void state_drawUI_logos ( void )

Definition at line 255 of file state_logos.c.

                              {
    appendGfx_intro_logos();
}

◆ state_init_title_screen()

void state_init_title_screen ( void )

Definition at line 122 of file state_title_screen.c.

                                   {
    s32 titleDataSize;
    void* titleDataDst;
    void* titleData;
 
    gOverrideFlags = 0;
    gTimeFreezeMode = TIME_FREEZE_NONE;
    general_heap_create();
    clear_printers();
    sfx_set_reverb_mode(0);
    gGameStatusPtr->startupState = TITLE_STATE_INIT;
    gGameStatusPtr->logoTime = 0;
    gGameStatusPtr->context = CONTEXT_WORLD;
    gGameStatusPtr->introPart = INTRO_PART_NONE;
    startup_fade_screen_update();
    titleData = load_asset_by_name("title_data", &titleDataSize);
    titleDataDst = TitleScreen_ImgList = heap_malloc(titleDataSize);
    decode_yay0(titleData, titleDataDst);
    general_heap_free(titleData);
 
    TitleScreen_ImgList_Logo = (s32*)(TitleScreen_ImgList->logo + (s32) TitleScreen_ImgList);
    TitleScreen_ImgList_Copyright = (u8 (*)[COPYRIGHT_WIDTH]) ((s32*)(TitleScreen_ImgList->copyright + (s32) TitleScreen_ImgList));
    TitleScreen_ImgList_PressStart = (s32*)(TitleScreen_ImgList->pressStart + (s32) TitleScreen_ImgList);
#if VERSION_JP
    TitleScreen_ImgList_CopyrightPalette = (s32*)(TitleScreen_ImgList->copyrightPalette + (s32) TitleScreen_ImgList);
#endif
 
    create_cameras();
    gCameras[CAM_DEFAULT].updateMode = CAM_UPDATE_NO_INTERP;
    gCameras[CAM_DEFAULT].needsInit = TRUE;
    gCameras[CAM_DEFAULT].nearClip = CAM_NEAR_CLIP;
    gCameras[CAM_DEFAULT].farClip = CAM_FAR_CLIP;
    gCameras[CAM_DEFAULT].vfov = 25.0f;
    set_cam_viewport(CAM_DEFAULT, 12, 28, 296, 184);
 
    gCameras[CAM_DEFAULT].params.basic.skipRecalc = FALSE;
    gCameras[CAM_DEFAULT].params.basic.pitch = 0;
    gCameras[CAM_DEFAULT].params.basic.dist = 40;
    gCameras[CAM_DEFAULT].params.basic.fovScale = 100;
 
    gCameras[CAM_DEFAULT].lookAt_eye.x = 500.0f;
    gCameras[CAM_DEFAULT].lookAt_eye.y = 1000.0f;
    gCameras[CAM_DEFAULT].lookAt_eye.z = 1500.0f;
 
    gCameras[CAM_DEFAULT].lookAt_obj_target.x = 25.0f;
    gCameras[CAM_DEFAULT].lookAt_obj_target.y = 25.0f;
    gCameras[CAM_DEFAULT].lookAt_obj_target.z = 150.0f;
 
    gCameras[CAM_DEFAULT].bgColor[0] = 0;
    gCameras[CAM_DEFAULT].bgColor[1] = 0;
    gCameras[CAM_DEFAULT].bgColor[2] = 0;
 
    gCurrentCameraID = CAM_DEFAULT;
 
    gCameras[CAM_DEFAULT].flags |= CAMERA_FLAG_DISABLED;
    gCameras[CAM_BATTLE].flags |= CAMERA_FLAG_DISABLED;
    gCameras[CAM_TATTLE].flags |= CAMERA_FLAG_DISABLED;
    gCameras[CAM_HUD].flags |= CAMERA_FLAG_DISABLED;
 
    clear_script_list();
    clear_worker_list();
    clear_render_tasks();
    spr_init_sprites(PLAYER_SPRITES_MARIO_WORLD);
    clear_animator_list();
    clear_entity_models();
    clear_npcs();
    hud_element_clear_cache();
    reset_background_settings();
    clear_entity_data(TRUE);
    clear_effect_data();
    gOverrideFlags |= GLOBAL_OVERRIDES_DISABLE_RENDER_WORLD;
    clear_player_data();
    gOverrideFlags &= ~GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
    set_game_mode_render_frontUI(appendGfx_title_screen);
    load_map_bg("title_bg");
    set_background(&gBackgroundImage);
    bgm_set_song(0, SONG_MAIN_THEME, 0, 500, 8);
    TitleScreen_TimeLeft = 480;
}

◆ state_step_title_screen()

void state_step_title_screen ( void )

Definition at line 202 of file state_title_screen.c.

                                   {
    s32 temp;
    u32 pressedButtons = gGameStatusPtr->pressedButtons[0];
 
    set_curtain_scale(1.0f);
    set_curtain_fade(0.0f);
 
    if (TitleScreen_TimeLeft > 0) {
        TitleScreen_TimeLeft--;
    }
 
    switch (gGameStatusPtr->startupState) {
        case TITLE_STATE_INIT:
            TitleScreen_AppearDelay = 3;
            gOverrideFlags |= GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
            gGameStatusPtr->titleScreenDismissTime = 20;
            gGameStatusPtr->titleScreenTimer = gGameStatusPtr->titleScreenDismissTime;
            gGameStatusPtr->startupState++;
            break;
        case TITLE_STATE_APPEAR:
            if (TitleScreen_AppearDelay != 0) {
                TitleScreen_AppearDelay--;
                break;
            }
            if (gGameStatusPtr->titleScreenTimer != 0) {
                gGameStatusPtr->titleScreenTimer--;
            }
            gOverrideFlags &= ~GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
            if (startup_fade_screen_in(6) != 0) {
                if (gGameStatusPtr->titleScreenTimer == 0) {
                    gGameStatusPtr->startupState = TITLE_STATE_HOLD;
                }
            }
            startup_fade_screen_update();
            break;
        case TITLE_STATE_HOLD:
 
            #if DX_SKIP_DEMO && DX_SKIP_STORY
            // play neither demo nor story
            TitleScreen_TimeLeft = 200;
            #elif DX_SKIP_DEMO
            // only the story may play
            if (TitleScreen_TimeLeft == 120) {
                bgm_set_song(0, -1, 0, 3900, 8);
            }
            if (TitleScreen_TimeLeft == 0) {
                gGameStatusPtr->startupState = TITLE_STATE_BEGIN_DISMISS;
                TitleScreenNextState = NEXT_STATE_INTRO;
                return;
            }
            #elif DX_SKIP_STORY
            // only the demo may play
            if (TitleScreen_TimeLeft == 0) {
                gGameStatusPtr->startupState = TITLE_STATE_BEGIN_DISMISS;
                TitleScreenNextState = NEXT_STATE_DEMO;
                return;
            }
            #else
            // allow either demo or story to play
            if (PlayIntroNext && TitleScreen_TimeLeft == 120) {
                bgm_set_song(0, -1, 0, 3900, 8);
            }
            if (TitleScreen_TimeLeft == 0) {
                gGameStatusPtr->startupState = TITLE_STATE_BEGIN_DISMISS;
                if (!PlayIntroNext) {
                    TitleScreenNextState = NEXT_STATE_DEMO;
                } else {
                    TitleScreenNextState = NEXT_STATE_INTRO;
                }
                PlayIntroNext ^= 1;
                return;
            }
            #endif
            if (pressedButtons & (BUTTON_A | BUTTON_START)) {
                gGameStatusPtr->startupState = TITLE_STATE_BEGIN_DISMISS;
                TitleScreenNextState = NEXT_STATE_FILE_SELECT;
                sfx_play_sound(SOUND_FILE_MENU_IN);
                bgm_set_song(0, SONG_FILE_SELECT, 0, 500, 8);
                return;
            }
            break;
        case TITLE_STATE_BEGIN_DISMISS:
            gGameStatusPtr->startupState = TITLE_STATE_DISMISS;
            startup_set_fade_screen_color(208);
            if (TitleScreenNextState == NEXT_STATE_INTRO || TitleScreenNextState == NEXT_STATE_DEMO) {
                gGameStatusPtr->titleScreenDismissTime = 20;
            } else {
                gGameStatusPtr->titleScreenDismissTime = 10;
            }
            gGameStatusPtr->titleScreenTimer = gGameStatusPtr->titleScreenDismissTime;
            break;
        case TITLE_STATE_DISMISS:
            if (TitleScreenNextState == NEXT_STATE_INTRO || TitleScreenNextState == NEXT_STATE_DEMO) {
                if (gGameStatusPtr->titleScreenTimer != 0) {
                    gGameStatusPtr->titleScreenTimer--;
                }
                if (startup_fade_screen_out(10) != 0) {
                    if (gGameStatusPtr->titleScreenTimer == 0) {
                        gGameStatusPtr->titleScreenTimer = 3;
                        gOverrideFlags |= GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
                        gGameStatusPtr->startupState = TITLE_STATE_EXIT;
                    }
                }
                startup_fade_screen_update();
            } else if (TitleScreenNextState == NEXT_STATE_FILE_SELECT) {
                if (gGameStatusPtr->titleScreenTimer == 0) {
                    gGameStatusPtr->titleScreenTimer = 3;
                    gOverrideFlags |= GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
                    gGameStatusPtr->startupState = TITLE_STATE_EXIT;
                } else {
                    gGameStatusPtr->titleScreenTimer--;
                }
            } else {
                gGameStatusPtr->titleScreenTimer = 3;
                gOverrideFlags |= GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
                gGameStatusPtr->startupState = TITLE_STATE_EXIT;
            }
            break;
        case TITLE_STATE_EXIT:
            if (gGameStatusPtr->titleScreenTimer != 0) {
                gGameStatusPtr->titleScreenTimer--;
                break;
            }
            general_heap_create();
            clear_render_tasks();
            create_cameras();
            clear_entity_models();
            clear_animator_list();
            clear_npcs();
            hud_element_clear_cache();
            spr_init_sprites(PLAYER_SPRITES_MARIO_WORLD);
            clear_entity_data(TRUE);
            clear_windows();
            gOverrideFlags &= ~GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
            gOverrideFlags &= ~GLOBAL_OVERRIDES_DISABLE_RENDER_WORLD;
            gGameStatusPtr->entryID = 0;
 
            switch (TitleScreenNextState) {
                case NEXT_STATE_INTRO:
                    gGameStatusPtr->introPart = INTRO_PART_0;
                    set_game_mode(GAME_MODE_INTRO);
                    break;
                case NEXT_STATE_DEMO:
                    set_game_mode(GAME_MODE_DEMO);
                    break;
                case NEXT_STATE_FILE_SELECT:
                    gGameStatusPtr->areaID = AREA_KMR;
                    gGameStatusPtr->mapID = 0xB; //TODO hardcoded map IDs
                    gGameStatusPtr->entryID = 0;
                    set_game_mode(GAME_MODE_FILE_SELECT);
                    break;
            }
            return;
    }
 
    if (!(gOverrideFlags & GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME)) {
        update_npcs();
        update_cameras();
    }
}

◆ state_drawUI_title_screen()

void state_drawUI_title_screen ( void )

Definition at line 363 of file state_title_screen.c.

                                     {
    switch (gGameStatusPtr->startupState) {
        case TITLE_STATE_INIT:
            PressStart_Alpha = 0;
            PressStart_IsVisible = FALSE;
            PressStart_BlinkCounter = 0;
            break;
        case TITLE_STATE_HOLD:
            if (gGameStatusPtr->contBitPattern & 1) {
                title_screen_draw_press_start();
            }
        case TITLE_STATE_UNUSED:
            break;
        case TITLE_STATE_APPEAR:
        case TITLE_STATE_BEGIN_DISMISS:
        case TITLE_STATE_DISMISS:
            break;
    }
}

◆ state_init_enter_demo()

void state_init_enter_demo ( void )

Definition at line 21 of file state_map_transitions.c.

                                 {
    gLoadedFromFileSelect = FALSE;
    init_enter_world_shared();
}

◆ state_step_enter_world()

void state_step_enter_world ( void )

Definition at line 46 of file state_map_transitions.c.

                                  {
    switch (gMapTransitionState) {
        case ENTER_WORLD_LOAD_MAP:
            if (gMapTransitionStateTime != 0) {
                gMapTransitionStateTime--;
                break;
            }
 
            gGameStatusPtr->context = CONTEXT_WORLD;
            gGameStatusPtr->debugScripts = DEBUG_SCRIPTS_NONE;
 
            if (!gLoadedFromFileSelect) {
                load_map_by_IDs(gGameStatusPtr->areaID, gGameStatusPtr->mapID, LOAD_FROM_MAP);
            } else {
                load_map_by_IDs(gGameStatusPtr->areaID, gGameStatusPtr->mapID, LOAD_FROM_FILE_SELECT);
            }
 
            gGameStatusPtr->prevArea = gGameStatusPtr->areaID;
            set_time_freeze_mode(TIME_FREEZE_NONE);
            if (gGameStatusPtr->demoState == DEMO_STATE_NONE) {
                disable_player_input();
            }
            update_cameras();
            gMapTransitionStateTime = 2;
            gMapTransitionState++;
            break;
        case ENTER_WORLD_AWAIT_MAIN:
            update_encounters();
            update_npcs();
            update_player();
            update_cameras();
 
            if (gMapTransitionStateTime != 0) {
                gMapTransitionStateTime--;
                break;
            }
            if (!does_script_exist(gGameStatusPtr->mainScriptID)) {
                gOverrideFlags &= ~GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
                gMapTransitionState++;
            }
            break;
        case ENTER_WORLD_FADE_IN:
            update_npcs();
            update_player();
            update_effects();
            update_cameras();
 
            if (update_enter_map_screen_overlay(&gMapTransitionAlpha) != 0) {
                if (gGameStatusPtr->demoState == DEMO_STATE_NONE) {
                    enable_player_input();
                }
                set_screen_overlay_params_front(OVERLAY_NONE, -1.0f);
                set_game_mode(GAME_MODE_WORLD);
            }
            break;
    }
}

◆ state_init_change_map()

void state_init_change_map ( void )

Definition at line 119 of file state_map_transitions.c.

                                 {
    gMapTransitionAlpha = 0;
    gMapTransitionFadeRate = 20;
    gMapTransitionState = CHANGE_MAP_INIT;
 
    if (gGameStatusPtr->prevArea != gGameStatusPtr->areaID) {
        gGameStatusPtr->didAreaChange = TRUE;
        gGameStatusPtr->prevArea = gGameStatusPtr->areaID;
    } else {
        gGameStatusPtr->didAreaChange = FALSE;
    }
}

◆ state_step_change_map()

void state_step_change_map ( void )

Definition at line 132 of file state_map_transitions.c.

                                 {
    switch (gMapTransitionState) {
        case CHANGE_MAP_INIT:
            update_npcs();
            update_player();
            update_effects();
            update_cameras();
 
            if (update_exit_map_screen_overlay(&gMapTransitionAlpha) != 0) {
                gMapTransitionState++;
            }
            break;
        case CHANGE_MAP_DELAY:
            gOverrideFlags |= GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
            nuContRmbForceStop();
            gMapTransitionStateTime = 4;
            gMapTransitionState++;
            break;
        case CHANGE_MAP_LOAD_MAP:
            if (gGameStatusPtr->demoState != DEMO_STATE_NONE) {
                set_game_mode(GAME_MODE_DEMO);
            }
 
            if (gMapTransitionStateTime != 0) {
                gMapTransitionStateTime--;
            } else {
                gGameStatusPtr->context = CONTEXT_WORLD;
                gGameStatusPtr->debugScripts = DEBUG_SCRIPTS_NONE;
                load_map_by_IDs(gGameStatusPtr->areaID, gGameStatusPtr->mapID, LOAD_FROM_MAP);
                set_time_freeze_mode(TIME_FREEZE_NONE);
                nuContRmbForceStopEnd();
                if (gGameStatusPtr->demoState == DEMO_STATE_NONE) {
                    disable_player_input();
                }
                update_cameras();
                gMapTransitionStateTime = 2;
                gMapTransitionState++;
            }
            break;
        case CHANGE_MAP_AWAIT_MAIN:
            update_encounters();
            update_npcs();
            update_player();
            update_cameras();
 
            if (gMapTransitionStateTime != 0) {
                gMapTransitionStateTime--;
            } else if (!does_script_exist(gGameStatusPtr->mainScriptID)) {
                gOverrideFlags &= ~GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
                gMapTransitionState++;
            }
            break;
        case CHANGE_MAP_FADE_IN:
            update_npcs();
            update_player();
            update_effects();
            update_cameras();
 
            if (update_enter_map_screen_overlay(&gMapTransitionAlpha) != 0) {
                if (gGameStatusPtr->demoState == DEMO_STATE_NONE) {
                    enable_player_input();
                }
                set_screen_overlay_params_front(OVERLAY_NONE, -1.0f);
                set_game_mode(GAME_MODE_WORLD);
            }
            break;
        }
}

◆ state_drawUI_change_map()

void state_drawUI_change_map ( void )

Definition at line 201 of file state_map_transitions.c.

                                   {
    if (gMapTransitionState == CHANGE_MAP_FADE_IN || gMapTransitionState == CHANGE_MAP_INIT) {
        draw_status_ui();
    }
}

◆ state_init_game_over()

void state_init_game_over ( void )

Definition at line 214 of file state_map_transitions.c.

                                {
    gMapTransitionAlpha = 255;
    gMapTransitionFadeRate = 20;
    gMapTransitionState = GAME_OVER_INIT;
    gPlayerStatus.flags |= PS_FLAG_NO_STATIC_COLLISION;
}

◆ state_step_game_over()

void state_step_game_over ( void )

Definition at line 221 of file state_map_transitions.c.

                                {
    switch (gMapTransitionState) {
        case GAME_OVER_INIT:
            gOverrideFlags |= GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
            nuContRmbForceStop();
            gMapTransitionStateTime = 4;
            gMapTransitionState++;
            break;
        case GAME_OVER_LOAD_MAP:
            if (gMapTransitionStateTime != 0) {
                gMapTransitionStateTime--;
            } else {
                gGameStatusPtr->context = CONTEXT_WORLD;
                gGameStatusPtr->debugScripts = DEBUG_SCRIPTS_NONE;
                load_map_by_IDs(gGameStatusPtr->areaID, gGameStatusPtr->mapID, LOAD_FROM_MAP);
                nuContRmbForceStopEnd();
                gMapTransitionState++;
            }
            break;
        case GAME_OVER_AWAIT_MAIN:
            update_encounters();
            update_npcs();
            if (!does_script_exist(gGameStatusPtr->mainScriptID)) {
                gOverrideFlags &= ~GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
                gMapTransitionState++;
                break;
            }
            return;
        case GAME_OVER_FADE_IN:
            gMapTransitionAlpha -= gMapTransitionFadeRate;
            if (gMapTransitionAlpha < 0) {
                gMapTransitionAlpha = 0;
                gMapTransitionState++;
                set_screen_overlay_params_front(OVERLAY_NONE, -1.0f);
                set_game_mode(GAME_MODE_WORLD);
            }
            update_npcs();
            update_player();
            update_effects();
            update_cameras();
            break;
    }
 
    set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, gMapTransitionAlpha);
}

◆ state_drawUI_game_over()

void state_drawUI_game_over ( void )

Definition at line 267 of file state_map_transitions.c.

267 {

268}

◆ state_init_enter_world()

void state_init_enter_world ( void )

Definition at line 26 of file state_map_transitions.c.

                                  {
    gLoadedFromFileSelect = TRUE;
    set_map_transition_effect(TRANSITION_ENTER_WORLD);
    init_enter_world_shared();
}

◆ state_drawUI_enter_world()

void state_drawUI_enter_world ( void )

Definition at line 104 of file state_map_transitions.c.

                                    {
    // startupState is being used as a timer here
    if (gGameStatusPtr->startupState == 2) {
        draw_status_ui();
    }
}

◆ state_init_world()

void state_init_world ( void )

Definition at line 10 of file state_world.c.

                            {
    set_game_mode_render_frontUI(state_world_draw_aux_ui);
 
#ifdef DX_QUICK_LAUNCH_BATTLE
    if (gGameStatus.loadType == LOAD_FROM_FILE_SELECT) {
        dx_debug_begin_battle_with_IDs(DX_QUICK_LAUNCH_BATTLE);
    }
#endif
}

◆ state_step_world()

void state_step_world ( void )

Definition at line 20 of file state_world.c.

                            {
    update_encounters();
    profiler_update(PROFILE_TIME_WORLD_ENCOUNTERS, 0);
    update_npcs();
    profiler_update(PROFILE_TIME_WORLD_NPCS, 0);
    update_player();
    profiler_update(PROFILE_TIME_WORLD_PLAYER, 0);
    update_item_entities();
    profiler_update(PROFILE_TIME_WORLD_ITEM_ENTITIES, 0);
    update_effects();
    profiler_update(PROFILE_TIME_WORLD_EFFECTS, 0);
    update_cameras();
    profiler_update(PROFILE_TIME_WORLD_CAMERAS, 0);
}

◆ state_drawUI_world()

void state_drawUI_world ( void )

Definition at line 35 of file state_world.c.

                              {
    draw_status_ui();
    draw_encounter_ui();
    imgfx_update_cache();
}

◆ state_init_battle()

void state_init_battle ( void )

Definition at line 32 of file state_battle.c.

                             {
    D_800A0900 = 5;
}

◆ state_step_battle()

void state_step_battle ( void )

Definition at line 36 of file state_battle.c.

                             {
    u32 currentBattleSelection;
    u32 currentBattleIndex;
 
    if (D_800A0900 == 5) {
        if (nuGfxCfb[1] != nuGfxCfb_ptr) {
            return;
        }
        D_800A0900--;
        gOverrideFlags |= GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
        nuContRmbForceStop();
    }
 
    if (D_800A0900 >= 0) {
        if (D_800A0900 > 0) {
            D_800A0900--;
            return;
        }
 
        D_800A0900 = -1;
        nuGfxSetCfb(bFrameBuffers, 2);
        nuContRmbForceStopEnd();
        sfx_stop_env_sounds();
        func_8003B1A8();
        gGameStatusPtr->context = CONTEXT_BATTLE;
        backup_map_collision_data();
 
#if !VERSION_IQUE
        load_obfuscation_shims();
#endif
        shim_battle_heap_create_obfuscated();
 
        sfx_clear_env_sounds(0);
 
        currentBattleSelection = UNPACK_BTL_AREA(gCurrentBattleID);
        currentBattleIndex = UNPACK_BTL_INDEX(gCurrentBattleID);
 
        if (gGameStatusPtr->peachFlags & PEACH_FLAG_IS_PEACH ||
            (currentBattleSelection == BTL_AREA_KKJ && currentBattleIndex == 0)) {
            gGameStatusPtr->peachFlags |= PEACH_FLAG_IS_PEACH;
            spr_init_sprites(PLAYER_SPRITES_PEACH_BATTLE);
        } else {
            spr_init_sprites(PLAYER_SPRITES_MARIO_BATTLE);
        }
 
        clear_model_data();
        clear_sprite_shading_data();
        reset_background_settings();
        clear_entity_models();
        clear_animator_list();
        clear_worker_list();
        hud_element_set_aux_cache(NULL, 0);
        hud_element_clear_cache();
        reset_status_bar();
        clear_item_entity_data();
        clear_script_list();
        clear_npcs();
        clear_entity_data(TRUE);
        clear_trigger_data();
        DMA_COPY_SEGMENT(battle_code);
        initialize_battle();
        btl_save_world_cameras();
        load_battle_section();
        D_800A0904 = gPlayerStatusPtr->animFlags;
        gPlayerStatusPtr->animFlags &= ~PA_FLAG_PULSE_STONE_VISIBLE;
        D_800A0908 = get_time_freeze_mode();
        set_time_freeze_mode(TIME_FREEZE_NONE);
        gOverrideFlags &= ~GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
 
        if (D_800A0900 >= 0) {
            return;
        }
    }
 
    update_encounters();
    btl_update();
    update_npcs();
    update_item_entities();
    update_effects();
    update_cameras();
}

◆ state_drawUI_battle()

void state_drawUI_battle ( void )

Definition at line 118 of file state_battle.c.

                               {
    draw_encounter_ui();
    if (D_800A0900 < 0) {
        btl_draw_ui();
    }
}

◆ state_init_end_battle()

void state_init_end_battle ( void )

Definition at line 125 of file state_battle.c.

                                 {
    gOverrideFlags |= GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
    nuContRmbForceStop();
    D_800A0900 = 5;
}

◆ state_step_end_battle()

void state_step_end_battle ( void )

Definition at line 131 of file state_battle.c.

                                 {
    PlayerStatus* playerStatus = &gPlayerStatus;
    PlayerData* playerData = &gPlayerData;
    MapSettings* mapSettings;
    MapConfig* mapConfig;
 
    if (D_800A0900 >= 0) {
        D_800A0900--;
        if (D_800A0900 == 0) {
            D_800A0900 = -1;
            nuGfxSetCfb(bFrameBuffers, 3);
            gOverrideFlags &= ~GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
            nuContRmbForceStopEnd();
            sfx_stop_env_sounds();
            mapSettings = get_current_map_settings();
            mapConfig = &gAreas[gGameStatusPtr->areaID].maps[gGameStatusPtr->mapID];
            btl_restore_world_cameras();
            gGameStatusPtr->context = CONTEXT_WORLD;
            func_8005AF84();
            func_8002ACDC();
            sfx_clear_env_sounds(1);
            gGameStatusPtr->peachFlags &= ~PEACH_FLAG_IS_PEACH;
            battle_heap_create();
            spr_init_sprites(gGameStatusPtr->playerSpriteSet);
            init_model_data();
            init_sprite_shading_data();
            init_entity_models();
            reset_animator_list();
            init_worker_list();
            hud_element_set_aux_cache(0, 0);
            init_hud_element_list();
            init_item_entity_list();
            init_script_list();
            init_npc_list();
            init_entity_data();
            init_trigger_list();
 
            if (gGameStatusPtr->demoBattleFlags & DEMO_BTL_FLAG_ENABLED) {
                npc_reload_all();
                playerStatus->animFlags = D_800A0904;
                set_game_mode(GAME_MODE_DEMO);
            } else {
                void* mapShape;
                u32 sizeTemp;
 
                partner_init_after_battle(playerData->curPartner);
                load_map_script_lib();
                mapShape = load_asset_by_name(wMapShapeName, &sizeTemp);
                decode_yay0(mapShape, &gMapShapeData);
                general_heap_free(mapShape);
                initialize_collision();
                restore_map_collision_data();
 
                if (mapConfig->dmaStart != NULL) {
                    dma_copy(mapConfig->dmaStart, mapConfig->dmaEnd, mapConfig->dmaDest);
                }
 
                load_map_bg(mapConfig->bgName);
                if (mapSettings->background != NULL) {
                    set_background(mapSettings->background);
                } else {
                    set_background_size(296, 200, 12, 20);
                }
 
                mdl_load_all_textures(mapSettings->modelTreeRoot, get_asset_offset(wMapTexName, &sizeTemp), sizeTemp);
                mdl_calculate_model_sizes();
                npc_reload_all();
 
                playerStatus->animFlags = D_800A0904;
                if (D_800A0908 != 0) {
                    set_time_freeze_mode(D_800A0908);
                }
                set_game_mode(GAME_MODE_WORLD);
            }
        }
    }
}

◆ state_drawUI_end_battle()

void state_drawUI_end_battle ( void )

Definition at line 209 of file state_battle.c.

209 {

210}

◆ state_init_pause()

void state_init_pause ( void )

Definition at line 51 of file state_pause.c.

                            {
    StepPauseState = 0;
    StepPauseAlpha = 0;
    disable_player_input();
    set_time_freeze_mode(TIME_FREEZE_POPUP_MENU);
    set_windows_visible(WINDOW_GROUP_PAUSE);
}

◆ state_step_pause()

void state_step_pause ( void )

Definition at line 61 of file state_pause.c.

                            {
    switch (StepPauseState) {
        case 0:
            update_encounters();
            update_npcs();
            update_player();
            update_effects();
            if (nuGfxCfb[1] == nuGfxCfb_ptr) {
                StepPauseDelay = 4;
                StepPauseState = 2;
                gOverrideFlags |= GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
                gGameStatusPtr->backgroundFlags &= ~BACKGROUND_RENDER_STATE_MASK;
                gGameStatusPtr->backgroundFlags |= BACKGROUND_RENDER_STATE_BEGIN_PAUSED;
 
            }
            break;
        case 2:
            if (StepPauseDelay >= 0) {
                if (StepPauseDelay != 0) {
                    StepPauseDelay--;
                }
 
                if (StepPauseDelay == 0) {
                    StepPauseDelay = -1;
                    nuGfxSetCfb(pause_frameBuffers, 2);
                    gGameStatusPtr->savedBackgroundDarkness = gGameStatusPtr->backgroundDarkness;
                    sfx_stop_env_sounds();
                    func_8003B1A8();
                    gGameStatusPtr->context = CONTEXT_PAUSE;
                    backup_map_collision_data();
                    battle_heap_create();
                    nuContRmbForceStop();
                    sfx_clear_env_sounds(0);
                    spr_init_sprites(PLAYER_SPRITES_MARIO_WORLD);
                    clear_model_data();
                    clear_sprite_shading_data();
                    reset_background_settings();
                    clear_entity_models();
                    clear_animator_list();
                    clear_worker_list();
                    hud_element_set_aux_cache(D_80200000, 0x38000); // TODO shiftability (what should this symbol be?)
                    hud_element_clear_cache();
                    reset_status_bar();
                    clear_item_entity_data();
                    clear_script_list();
                    clear_npcs();
                    clear_entity_data(FALSE);
                    clear_trigger_data();
                    SavedReverbMode = sfx_get_reverb_mode();
                    sfx_set_reverb_mode(0);
                    bgm_quiet_max_volume();
                    nuPiReadRomOverlay(&PauseOverlaySegment);
                    pause_init();
                    gOverrideFlags &= ~GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
                }
 
                if (StepPauseDelay >= 0) {
                    break;
                }
            }
 
            if (StepPauseDelay >= -10) {
                pause_handle_input(0, 0);
                StepPauseDelay--;
            } else {
                pause_handle_input(gGameStatusPtr->pressedButtons[0], gGameStatusPtr->heldButtons[0]);
            }
            StepPauseAlpha = 0;
            break;
    }
}

◆ state_drawUI_pause()

void state_drawUI_pause ( void )

Definition at line 133 of file state_pause.c.

133 {

134}

◆ state_init_unpause()

void state_init_unpause ( void )

Definition at line 136 of file state_pause.c.

                              {
    if (StepPauseAlpha > 0) {
        StepPauseState = 0;
    } else {
        StepPauseState = 1;
    }
    StepPauseDelay = 4;
}

◆ state_step_unpause()

void state_step_unpause ( void )

Definition at line 145 of file state_pause.c.

                              {
    MapSettings* mapSettings;
    MapConfig* mapConfig;
    void* mapShape;
    u32 assetSize;
 
    switch (StepPauseState) {
        case 0:
        case 1:
            if (StepPauseDelay == 4) {
                gOverrideFlags |= GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
            }
 
            if (StepPauseDelay >= 0) {
                if (StepPauseDelay != 0) {
                    StepPauseDelay--;
                }
 
                if (StepPauseDelay == 0) {
                    StepPauseDelay = -1;
                    nuGfxSetCfb(pause_frameBuffers, ARRAY_COUNT(pause_frameBuffers));
                    pause_cleanup();
                    gOverrideFlags &= ~GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
                    mapSettings = get_current_map_settings();
                    mapConfig = &gAreas[gGameStatusPtr->areaID].maps[gGameStatusPtr->mapID];
                    gGameStatusPtr->context = CONTEXT_WORLD;
                    gGameStatusPtr->backgroundFlags &= ~BACKGROUND_RENDER_STATE_MASK;
                    func_8005AF84();
                    func_8002ACDC();
                    nuContRmbForceStopEnd();
                    sfx_clear_env_sounds(1);
                    spr_init_sprites(gGameStatusPtr->playerSpriteSet);
                    init_model_data();
                    init_sprite_shading_data();
                    init_entity_models();
                    reset_animator_list();
                    init_worker_list();
                    hud_element_set_aux_cache(0, 0);
                    init_hud_element_list();
                    init_item_entity_list();
                    init_script_list();
                    init_npc_list();
                    init_entity_data();
                    init_trigger_list();
                    sfx_set_reverb_mode(SavedReverbMode);
                    bgm_reset_max_volume();
                    load_map_script_lib();
                    mapShape = load_asset_by_name(wMapShapeName, &assetSize);
                    decode_yay0(mapShape, &gMapShapeData);
                    general_heap_free(mapShape);
                    initialize_collision();
                    restore_map_collision_data();
 
                    if (mapConfig->dmaStart != NULL) {
                        dma_copy(mapConfig->dmaStart, mapConfig->dmaEnd, mapConfig->dmaDest);
                    }
 
                    load_map_bg(mapConfig->bgName);
                    if (mapSettings->background != NULL) {
                        set_background(mapSettings->background);
                    } else {
                        set_background_size(296, 200, 12, 20);
                    }
 
                    gGameStatusPtr->backgroundDarkness = gGameStatusPtr->savedBackgroundDarkness;
                    mdl_calculate_model_sizes();
                    npc_reload_all();
                    set_windows_visible(WINDOW_GROUP_ALL);
                    status_bar_respond_to_changes();
                    set_time_freeze_mode(TIME_FREEZE_PARTIAL);
                    StepPauseState = 3;
                    gPlayerStatus.prevAlpha = gPlayerStatus.curAlpha - 1;
                    ReflectFloorPrevAlpha = ReflectWallPrevAlpha + 1; // ???
 
                    update_encounters();
                    update_npcs();
                    update_player();
                    update_effects();
 
                    StepPauseAlpha -= 20;
                    if (StepPauseAlpha < 0) {
                        StepPauseAlpha = 0;
                    }
                }
            }
            break;
        case 3:
            update_encounters();
            update_npcs();
            update_player();
            update_effects();
 
            if (StepPauseAlpha == 0) {
                StepPauseState = 4;
            } else {
                StepPauseAlpha -= 20;
                if (StepPauseAlpha < 0) {
                    StepPauseAlpha = 0;
                }
            }
            break;
        case 4:
            set_time_freeze_mode(TIME_FREEZE_NONE);
            update_encounters();
            update_npcs();
            update_player();
            update_effects();
            enable_player_input();
            set_game_mode(GAME_MODE_WORLD);
            break;
    }
}

◆ state_drawUI_unpause()

void state_drawUI_unpause ( void )

Definition at line 258 of file state_pause.c.

258 {

259}

◆ state_init_file_select()

void state_init_file_select ( void )

Definition at line 48 of file state_file_select.c.

                                  {
    D_800A0931 = 0;
    D_800A0932 = 0;
    disable_player_input();
    set_time_freeze_mode(TIME_FREEZE_FULL);
    general_heap_create();
    hud_element_set_aux_cache(0, 0);
    hud_element_clear_cache();
    mdl_load_all_textures(NULL, 0, 0);
 
    gCameras[CAM_DEFAULT].updateMode = CAM_UPDATE_NO_INTERP;
    gCameras[CAM_DEFAULT].needsInit = TRUE;
    gCameras[CAM_DEFAULT].nearClip = CAM_NEAR_CLIP;
    gCameras[CAM_DEFAULT].farClip = CAM_FAR_CLIP;
    gCameras[CAM_DEFAULT].vfov = 25.0f;
    set_cam_viewport(CAM_DEFAULT, 12, 28, 296, 184);
 
    gCameras[CAM_DEFAULT].params.basic.skipRecalc = FALSE;
    gCameras[CAM_DEFAULT].params.basic.pitch = 0;
    gCameras[CAM_DEFAULT].params.basic.dist = 40;
    gCameras[CAM_DEFAULT].params.basic.fovScale = 100;
 
    gCameras[CAM_DEFAULT].lookAt_eye.x = 500.0f;
    gCameras[CAM_DEFAULT].lookAt_eye.y = 1000.0f;
    gCameras[CAM_DEFAULT].lookAt_eye.z = 1500.0f;
 
    gCameras[CAM_DEFAULT].lookAt_obj_target.x = 25.0f;
    gCameras[CAM_DEFAULT].lookAt_obj_target.y = 25.0f;
    gCameras[CAM_DEFAULT].lookAt_obj_target.z = 150.0f;
 
    gCameras[CAM_DEFAULT].bgColor[0] = 0;
    gCameras[CAM_DEFAULT].bgColor[1] = 0;
    gCameras[CAM_DEFAULT].bgColor[2] = 0;
 
    gCurrentCameraID = CAM_DEFAULT;
 
    gCameras[CAM_DEFAULT].flags |= CAMERA_FLAG_DISABLED;
    gCameras[CAM_BATTLE].flags |= CAMERA_FLAG_DISABLED;
    gCameras[CAM_TATTLE].flags |= CAMERA_FLAG_DISABLED;
    gCameras[CAM_HUD].flags |= CAMERA_FLAG_DISABLED;
 
    gOverrideFlags |= GLOBAL_OVERRIDES_WINDOWS_OVER_CURTAINS;
}

◆ state_step_file_select()

void state_step_file_select ( void )

Definition at line 92 of file state_file_select.c.

                                  {
    switch (D_800A0931) {
        case 0:
            D_800A0931 = 1;
            break;
        case 1:
            set_windows_visible(WINDOW_GROUP_FILES);
            D_800A0930 = 1;
            D_800A0931 = 2;
            break;
        case 2:
            if (D_800A0930 >= 0) {
                D_800A0930--;
                if (D_800A0930 == 0) {
                    D_800A0930 = -1;
                    battle_heap_create();
                    nuPiReadRomOverlay(&D_8007798C);
                    filemenu_init(0);
                }
            }
 
            if (D_800A0930 < 0) {
                filemenu_update();
            }
            break;
    }
}

◆ state_drawUI_file_select()

void state_drawUI_file_select ( void )

Definition at line 120 of file state_file_select.c.

120 {

121}

◆ state_init_exit_file_select()

void state_init_exit_file_select ( void )

Definition at line 123 of file state_file_select.c.

                                       {
    D_800A0931 = 0;
    D_800A0932 = 0;
    D_800A0930 = 0;
 
    if (filemenu_get_exit_mode() == 0) {
        set_map_transition_effect(TRANSITION_SLOW_FADE_TO_WHITE);
    } else {
        set_map_transition_effect(TRANSITION_ENTER_WORLD);
        gOverrideFlags &= ~GLOBAL_OVERRIDES_WINDOWS_OVER_CURTAINS;
        bgm_set_song(0, -1, 0, 1000, 8);
    }
    gOverrideFlags &= ~GLOBAL_OVERRIDES_40;
}

◆ state_step_exit_file_select()

void state_step_exit_file_select ( void )

Definition at line 138 of file state_file_select.c.

                                       {
    s32 exitMode = filemenu_get_exit_mode();
    s32 flagSum;
    s32 i;
 
    switch (D_800A0931) {
        case 0:
            flagSum = 0;
 
            for (i = 44; i < ARRAY_COUNT(gWindows); i++) {
                Window* window = &gWindows[i];
 
                if (window->parent == WIN_FILES_MAIN || window->parent == WIN_NONE) {
                    flagSum += window->flags & WINDOW_FLAG_INITIAL_ANIMATION;
                }
            }
 
            if (flagSum == 0) {
                D_800A0931 = 1;
            }
            break;
        case 1:
            if (exitMode == 0 || update_exit_map_screen_overlay(&D_800A0932) != 0) {
                D_800A0931 = 2;
            }
            break;
        case 2:
            filemenu_cleanup();
            set_windows_visible(WINDOW_GROUP_ALL);
            D_800A0931 = 3;
        case 3:
            set_time_freeze_mode(TIME_FREEZE_NONE);
            if (exitMode == 0) {
                set_game_mode(GAME_MODE_TITLE_SCREEN);
                gOverrideFlags &= ~GLOBAL_OVERRIDES_WINDOWS_OVER_CURTAINS;
            } else {
                D_800A0930 = 10;
                D_800A0931 = 4;
            }
            break;
        case 4:
            if (D_800A0930 > 0) {
                D_800A0930--;
            } else {
                set_curtain_scale_goal(2.0f);
                D_800A0930 = 10;
                D_800A0931 = 5;
            }
            break;
        case 5:
            if (D_800A0930 > 0) {
                D_800A0930--;
            } else {
                D_800A0931 = 6;
            }
            break;
        case 6:
            set_game_mode(GAME_MODE_ENTER_WORLD);
            break;
    }
}

◆ state_drawUI_exit_file_select()

void state_drawUI_exit_file_select ( void )

Definition at line 200 of file state_file_select.c.

200 {

201}

◆ state_init_intro()

void state_init_intro ( void )

Definition at line 26 of file state_intro.c.

                            {
    gGameStatusPtr->startupState = INTRO_INIT;
 
    set_curtain_scale_goal(1.0f);
    set_curtain_fade_goal(0.3f);
 
    switch (gGameStatusPtr->introPart) {
        case INTRO_PART_0:
            startup_set_fade_screen_alpha(0);
 
            IntroOverlayAlpha = 255;
            IntroFrontFadeAlpha = 16;
            IntroOverlayDelta = 4;
            IntroOverlayType = OVERLAY_SCREEN_COLOR;
            IntroFadeColorR = 208;
            IntroFadeColorG = 208;
            IntroFadeColorB = 208;
            D_800A0964 = 0;
 
            // hos_05 (Star Sanctuary)
            gGameStatusPtr->areaID = AREA_HOS;
            gGameStatusPtr->mapID = 5; //TODO hard-coded map ID
            gGameStatusPtr->entryID = 3;
            break;
        case INTRO_PART_1:
            startup_set_fade_screen_alpha(0);
 
            IntroOverlayAlpha = 0;
            IntroFrontFadeAlpha = 12;
            IntroOverlayDelta = 4;
            IntroOverlayType = OVERLAY_VIEWPORT_COLOR;
            IntroFadeColorR = 0;
            IntroFadeColorG = 0;
            IntroFadeColorB = 0;
            D_800A0964 = 0;
 
            // hos_04 (Outside the Sanctuary)
            gGameStatusPtr->areaID = AREA_HOS;
            gGameStatusPtr->mapID = 4; //TODO hard-coded map ID
            gGameStatusPtr->entryID = 4;
            break;
        default:
            startup_set_fade_screen_alpha(0);
            startup_set_fade_screen_color(208);
 
            gGameStatusPtr->introPart = INTRO_PART_NONE;
 
            IntroFrontFadeAlpha = 6;
            IntroOverlayDelta = 6;
 
            IntroMessageIdx++;
            if (IntroMessageIdx >= 4) {
                // both hos_04 and hos_05 have an IntroMessage array of length 4
                IntroMessageIdx = 0;
            }
 
            D_800A0964 = 3;
            break;
    }
 
    set_screen_overlay_params_back(IntroOverlayType, IntroOverlayAlpha);
    set_screen_overlay_color(SCREEN_LAYER_BACK, IntroFadeColorR, IntroFadeColorG, IntroFadeColorB);
 
    startup_fade_screen_update();
}

Referenced by state_step_intro().

◆ state_step_intro()

void state_step_intro ( void )

Definition at line 92 of file state_intro.c.

                            {
    PlayerData* playerData = &gPlayerData;
    u32 pressedButtons = gGameStatusPtr->pressedButtons[0];
    s32 i;
 
    #if DX_SKIP_STORY
    // immediately quit out of the state when skipping story
    pressedButtons = BUTTON_START;
    #endif
 
    if (gGameStatusPtr->introPart != INTRO_PART_NONE) {
        if (D_800A0964 == 0 && pressedButtons & (BUTTON_A | BUTTON_B | BUTTON_START | BUTTON_Z)) {
            D_800A0964 = 1;
        }
 
        if (D_800A0964 == 1 && (gGameStatusPtr->startupState == INTRO_INIT ||
                                gGameStatusPtr->startupState == INTRO_DISABLE_DRAW_FRAME ||
                                gGameStatusPtr->startupState == INTRO_FADE_IN))
        {
            gGameStatusPtr->introPart = INTRO_PART_100;
            state_init_intro();
            return;
        }
 
        if (D_800A0964 == 2 && (gGameStatusPtr->startupState == INTRO_INIT ||
                                gGameStatusPtr->startupState == INTRO_DISABLE_DRAW_FRAME ||
                                gGameStatusPtr->startupState == INTRO_FADE_IN))
        {
            gGameStatusPtr->introPart++;
            state_init_intro();
            return;
        }
    }
 
    switch (gGameStatusPtr->startupState) {
        case INTRO_INIT:
            update_effects();
            update_cameras();
            if (gGameStatusPtr->introPart == INTRO_PART_NONE) {
                set_curtain_fade_goal(0.0f);
                if (startup_fade_screen_out(IntroFrontFadeAlpha)) {
                    gGameStatusPtr->startupState = INTRO_DISABLE_DRAW_FRAME;
                    set_curtain_draw_callback(NULL);
                }
            } else {
                IntroOverlayAlpha += IntroFrontFadeAlpha;
                if (IntroOverlayAlpha >= 255) {
                    IntroOverlayAlpha = 255;
                    gGameStatusPtr->startupState = INTRO_DISABLE_DRAW_FRAME;
                    set_curtain_draw_callback(NULL);
                }
            }
            break;
        case INTRO_DISABLE_DRAW_FRAME:
            IntroEnableDrawFrameDelay = 4;
            gOverrideFlags |= GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
            // this condition is always true, likely leftover from an earlier version
            if (IntroOverlayType != OVERLAY_INTRO_1) {
                gGameStatusPtr->startupState = INTRO_LOAD_MAP;
            }
            break;
        case INTRO_ENABLE_DRAW_FRAME: // unused
            IntroEnableDrawFrameDelay--;
            if (IntroEnableDrawFrameDelay <= 0) {
                gOverrideFlags &= ~GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
                gGameStatusPtr->startupState = INTRO_LOAD_MAP;
            }
            break;
        case INTRO_LOAD_MAP:
            set_curtain_draw_callback(NULL);
            gGameStatusPtr->context = CONTEXT_WORLD;
            gGameStatusPtr->debugUnused1 = FALSE;
            gGameStatusPtr->debugScripts = DEBUG_SCRIPTS_NONE;
            gGameStatusPtr->keepUsingPartnerOnMapChange = FALSE;
 
            if (gGameStatusPtr->introPart == INTRO_PART_NONE) {
                general_heap_create();
                clear_render_tasks();
                clear_worker_list();
                clear_script_list();
                create_cameras();
                spr_init_sprites(PLAYER_SPRITES_MARIO_WORLD);
                clear_entity_models();
                clear_animator_list();
                clear_model_data();
                clear_sprite_shading_data();
                reset_background_settings();
                hud_element_clear_cache();
                clear_trigger_data();
                clear_printers();
                clear_entity_data(FALSE);
                clear_screen_overlays();
                clear_player_status();
                clear_npcs();
                clear_player_data();
                reset_battle_status();
                init_encounter_status();
                clear_effect_data();
                clear_item_entity_data();
                clear_saved_variables();
                initialize_collision();
                set_game_mode(GAME_MODE_TITLE_SCREEN);
                return;
            }
 
            playerData->curHP = 10;
            playerData->curMaxHP = 10;
            playerData->hardMaxHP = 10;
            playerData->curFP = 5;
            playerData->curMaxFP = 5;
            playerData->hardMaxFP = 5;
            playerData->maxBP = 2;
            playerData->bootsLevel = 0;
            playerData->hammerLevel = -1;
            playerData->level = 0;
 
            for (i = 0; i < ARRAY_COUNT(playerData->partners); i++) {
                playerData->partners[i].enabled = FALSE;
            }
 
            playerData->curPartner = PARTNER_NONE;
            load_map_by_IDs(gGameStatusPtr->areaID, gGameStatusPtr->mapID, LOAD_FROM_MAP);
            gGameStatusPtr->startupState = INTRO_AWAIT_MAIN;
            disable_player_input();
            break;
        case INTRO_AWAIT_MAIN:
            if (IntroOverlayType == OVERLAY_INTRO_1) {
                IntroOverlayType = OVERLAY_INTRO_2;
            }
            IntroOverlayAlpha = 255 - IntroOverlayDelta;
            gOverrideFlags &= ~GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
            gCameras[CAM_DEFAULT].flags &= ~CAMERA_FLAG_DISABLED;
            gOverrideFlags &= ~GLOBAL_OVERRIDES_DISABLE_RENDER_WORLD;
            update_player();
            update_encounters();
            update_npcs();
            update_effects();
            update_cameras();
            if (!does_script_exist(gGameStatusPtr->mainScriptID)) {
                gGameStatusPtr->prevArea = gGameStatusPtr->areaID;
                gGameStatusPtr->startupState = INTRO_FADE_IN;
                break;
            }
            return;
        case INTRO_FADE_IN:
            update_effects();
            update_cameras();
            update_npcs();
            if (IntroOverlayAlpha == 0) {
                set_screen_overlay_params_front(OVERLAY_NONE, -1.0f);
                set_screen_overlay_params_back(OVERLAY_NONE, -1.0f);
            } else {
                IntroOverlayAlpha -= IntroOverlayDelta;
                if (IntroOverlayAlpha < 0) {
                    IntroOverlayAlpha = 0;
                }
            }
            break;
    }
 
    set_screen_overlay_params_back(IntroOverlayType, IntroOverlayAlpha);
    set_screen_overlay_color(SCREEN_LAYER_BACK, IntroFadeColorR, IntroFadeColorG, IntroFadeColorB);
    startup_fade_screen_update();
}

◆ state_drawUI_intro()

void state_drawUI_intro ( void )

Definition at line 257 of file state_intro.c.

257 {

258}

◆ state_init_demo()

void state_init_demo ( void )

Definition at line 144 of file state_demo.c.

                           {
    if (gGameStatusPtr->demoState == DEMO_STATE_NONE) {
        gGameStatusPtr->nextDemoScene = 0;
        gGameStatusPtr->demoState = DEMO_STATE_ACTIVE;
    }
 
    gGameStatusPtr->demoButtonInput = 0;
    gGameStatusPtr->demoStickX = 0;
    gGameStatusPtr->demoStickY = 0;
 
    disable_sounds();
    set_map_transition_effect(TRANSITION_END_DEMO_SCENE_BLACK);
    set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, 255.0f);
    clear_saved_variables();
    clear_script_list();
}

◆ state_step_demo()

void state_step_demo ( void )

Definition at line 161 of file state_demo.c.

                           {
    PlayerData* playerData = &gPlayerData;
    DemoSceneData* demoSceneData = &DemoScenes[gGameStatusPtr->nextDemoScene];
    s16 mode = demoSceneData->sceneType;
    s16 mapID;
    s16 areaID;
 
    if (gGameStatusPtr->demoState == DEMO_STATE_4) {
        mode = DEMO_SCENE_DONE;
    }
    if (gGameStatusPtr->demoState == DEMO_STATE_DONE) {
        mode = DEMO_SCENE_EXIT;
    }
 
    switch (mode) {
        case DEMO_SCENE_DONE:
            startup_set_fade_screen_alpha(255);
            startup_set_fade_screen_color(224);
            gGameStatusPtr->startupState = 3;
            gOverrideFlags |= GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
            startup_fade_screen_update();
            gGameStatusPtr->demoState = DEMO_STATE_DONE;
            break;
        case DEMO_SCENE_EXIT:
            if (gGameStatusPtr->startupState != 0) {
                gGameStatusPtr->startupState--;
            }
 
            if (gGameStatusPtr->startupState == 0) {
                gGameStatusPtr->nextDemoScene = 0;
                gGameStatusPtr->demoState = DEMO_STATE_NONE;
                gGameStatusPtr->peachFlags = 0;
                enable_sounds();
                gGameStatusPtr->context = CONTEXT_WORLD;
                gGameStatusPtr->debugUnused1 = FALSE;
                gGameStatusPtr->debugScripts = DEBUG_SCRIPTS_NONE;
                gGameStatusPtr->keepUsingPartnerOnMapChange = FALSE;
                gOverrideFlags &= ~GLOBAL_OVERRIDES_DISABLE_DRAW_FRAME;
                general_heap_create();
                clear_render_tasks();
                clear_worker_list();
                clear_script_list();
                create_cameras();
                spr_init_sprites(PLAYER_SPRITES_MARIO_WORLD);
                clear_entity_models();
                clear_animator_list();
                clear_model_data();
                clear_sprite_shading_data();
                reset_background_settings();
                hud_element_clear_cache();
                clear_trigger_data();
                clear_printers();
                clear_entity_data(FALSE);
                clear_screen_overlays();
                clear_player_status();
                clear_npcs();
                clear_player_data();
                reset_battle_status();
                init_encounter_status();
                clear_effect_data();
                clear_item_entity_data();
                clear_saved_variables();
                initialize_collision();
                set_game_mode(GAME_MODE_TITLE_SCREEN);
            }
            return;
        case DEMO_SCENE_WORLD:
            get_map_IDs_by_name_checked(demoSceneData->mapName, &areaID, &mapID);
            gGameStatusPtr->areaID = areaID;
            gGameStatusPtr->mapID = mapID;
            gGameStatusPtr->entryID = demoSceneData->index;
            gGameStatusPtr->peachFlags = 0;
            playerData->curPartner = demoSceneData->partnerID;
            set_cam_viewport(CAM_DEFAULT, 29, 20, -262, 177);
            evt_set_variable(NULL, GB_StoryProgress, demoSceneData->storyProgress);
 
            if (gGameStatusPtr->nextDemoScene == 0) {
                set_map_transition_effect(TRANSITION_END_DEMO_SCENE_WHITE);
            } else {
                set_map_transition_effect(TRANSITION_END_DEMO_SCENE_BLACK);
            }
 
            set_game_mode(GAME_MODE_ENTER_DEMO_WORLD);
            break;
        case DEMO_SCENE_PEACH:
            get_map_IDs_by_name_checked(demoSceneData->mapName, &areaID, &mapID);
            gGameStatusPtr->areaID = areaID;
            gGameStatusPtr->mapID = mapID;
            gGameStatusPtr->entryID = demoSceneData->index;
            gGameStatusPtr->peachFlags = PEACH_FLAG_IS_PEACH;
            playerData->curPartner = demoSceneData->partnerID;
            set_cam_viewport(CAM_DEFAULT, 29, 20, -262, 177);
            evt_set_variable(NULL, GB_StoryProgress, demoSceneData->storyProgress);
 
            if (gGameStatusPtr->nextDemoScene == 0) {
                set_map_transition_effect(TRANSITION_END_DEMO_SCENE_WHITE);
            } else {
                set_map_transition_effect(TRANSITION_END_DEMO_SCENE_BLACK);
            }
 
            set_game_mode(GAME_MODE_ENTER_DEMO_WORLD);
            break;
        case DEMO_SCENE_BATTLE:
            load_demo_battle(demoSceneData->index);
            break;
    }
 
    gGameStatusPtr->nextDemoScene++;
    if (gGameStatusPtr->nextDemoScene > LAST_DEMO_SCENE_IDX) {
        gGameStatusPtr->nextDemoScene = LAST_DEMO_SCENE_IDX;
    }
}

◆ state_drawUI_demo()

void state_drawUI_demo ( void )

Definition at line 274 of file state_demo.c.

                             {
 
}

◆ btl_set_player_idle_anims()

void btl_set_player_idle_anims ( void )

Definition at line 40 of file player_events.c.

                                     {
    BattleStatus* battleStatus = &gBattleStatus;
    ActorPart* actorPart = &battleStatus->playerActor->partsTable[0];
 
    if (battleStatus->flags2 & BS_FLAGS2_PEACH_BATTLE) {
        actorPart->idleAnimations = bPeachIdleAnims;
        set_actor_anim(0, 0, ANIM_Peach1_Walk);
    } else if (!battleStatus->outtaSightActive) {
        actorPart->idleAnimations = bMarioIdleAnims;
    }
}

Referenced by btl_state_update_end_turn().

◆ shim_create_audio_system_obfuscated()

void shim_create_audio_system_obfuscated ( void )

Definition at line 9 of file obfuscation_shims.c.

                                               {
    DMA_COPY_SEGMENT(create_audio_system_obfuscated);
    create_audio_system_obfuscated();
}

Referenced by boot_main().

◆ shim_load_engine_data_obfuscated()

void shim_load_engine_data_obfuscated ( void )

Definition at line 14 of file obfuscation_shims.c.

                                            {
    DMA_COPY_SEGMENT(load_engine_data_obfuscated);
    load_engine_data_obfuscated();
}

Referenced by boot_main().

◆ shim_general_heap_create_obfuscated()

void shim_general_heap_create_obfuscated ( void )

Definition at line 19 of file obfuscation_shims.c.

                                               {
    DMA_COPY_SEGMENT(general_heap_create_obfuscated);
    general_heap_create_obfuscated();
}

Referenced by load_map_by_IDs().

◆ shim_battle_heap_create_obfuscated()

void shim_battle_heap_create_obfuscated ( void )

Definition at line 24 of file obfuscation_shims.c.

                                              {
    DMA_COPY_SEGMENT(battle_heap_create_obfuscated);
    battle_heap_create_obfuscated();
}

Referenced by state_step_battle().

◆ appendGfx_ispy_icon()

void appendGfx_ispy_icon ( void )

Definition at line 34 of file i_spy.c.

                               {
    Matrix4f matrix1;
    Matrix4f matrix2;
    ImgFXTexture ifxImg;
    s32 flashPhase;
 
    if (gPlayerStatus.animFlags & PA_FLAG_ISPY_VISIBLE) {
        guScaleF(matrix1, ISpyPtr->scale, ISpyPtr->scale, ISpyPtr->scale);
        guRotateF(matrix2, -gCameras[gCurrentCameraID].curYaw, 0.0f, 1.0f, 0.0f);
        guMtxCatF(matrix1, matrix2, matrix1);
        guTranslateF(matrix2, ISpyPtr->pos.x, ISpyPtr->pos.y, ISpyPtr->pos.z);
        guMtxCatF(matrix1, matrix2, matrix2);
        guMtxF2L(matrix2, &gDisplayContext->matrixStack[gMatrixListPos]);
 
        gSPMatrix(gMainGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++], 3);
        gSPDisplayList(gMainGfxPos++, ispy_icon_gfx);
 
        if (ISpyPtr->time < 47) {
            ISpyPtr->flashCount++;
        }
 
        flashPhase = ISpyPtr->flashCount;
        flashPhase = flashPhase % 12;
        switch (flashPhase) {
            case 0:
            case 1:
            case 2:
            case 3:
                ifxImg.palette = ispy_icon_1_pal;
                break;
            case 4:
            case 5:
            case 6:
            case 7:
                ifxImg.palette = ispy_icon_2_pal;
                break;
            case 8:
            case 9:
            case 10:
            case 11:
                ifxImg.palette = ispy_icon_3_pal;
                break;
        }
        imgfx_update(0, IMGFX_SET_ALPHA, 255, 255, 255, ISpyPtr->alpha, 0);
 
        ifxImg.raster = ispy_icon_img;
        ifxImg.width  = ispy_icon_img_width;
        ifxImg.height = ispy_icon_img_height;
        ifxImg.xOffset = -28;
        ifxImg.yOffset = 46;
        ifxImg.alpha = 255;
 
        imgfx_appendGfx_component(0, &ifxImg, 0, matrix2);
        gSPPopMatrix(gMainGfxPos++, 0);
    }
}

Referenced by render_ispy_icon().

◆ interact_inspect_setup()

void interact_inspect_setup ( void )

Definition at line 43 of file inspect_icon.c.

                                  {
    PlayerStatus* playerStatus = &gPlayerStatus;
    f32 new_var;
 
    if (playerStatus->animFlags & PA_FLAG_INTERACT_PROMPT_AVAILABLE) {
        mem_clear(InspectIconPtr, sizeof(*InspectIconPtr));
        D_8010C950 = -1;
        InspectIconPtr->pos.x = playerStatus->pos.x;
        InspectIconPtr->pos.y = playerStatus->pos.y + playerStatus->colliderHeight +
                                   (!(playerStatus->animFlags & PA_FLAG_USING_PEACH_PHYSICS) ? 8.0f : 2.0f);
        InspectIconPtr->pos.z = playerStatus->pos.z;
        InspectIconPtr->scale = 0.4f;
        InspectIconPtr->state = INSPECT_ICON_APPEAR;
        InspectIconPtr->yaw = -gCameras[gCurrentCameraID].curYaw;
        InteractNotificationCallback = interact_inspect_update;
        InspectIconPtr->brightness = 255;
        InspectIconPtr->alpha = 255;
    }
}

Referenced by check_for_interactables().

◆ interact_speech_setup()

void interact_speech_setup ( void )

Definition at line 25 of file speech_bubble.c.

                                 {
    PlayerStatus* playerStatus = &gPlayerStatus;
    SpeechBubbleData* temp;
    Npc* npc;
 
    mem_clear(SpeechBubblePtr, sizeof(*SpeechBubblePtr));
    npc = playerStatus->encounteredNPC;
    SpeechBubblePtr->encounteredNPC = npc;
    SpeechBubblePtr->pos.y = SpeechBubblePtr->unk_1C = npc->pos.y + npc->collisionHeight + 8.0f;
    SpeechBubblePtr->pos.x = npc->pos.x;
    SpeechBubblePtr->pos.z = npc->pos.z;
    SpeechBubblePtr->unk_18 = 0;
    SpeechBubblePtr->state = 0;
    SpeechBubblePtr->scale = 0.1f;
    TalkNotificationCallback = interact_speech_update;
    playerStatus->animFlags |= PA_FLAG_SPEECH_PROMPT_AVAILABLE;
    temp = SpeechBubblePtr;
    temp->state = 0;
    temp->scale = 0.4f;
    SpeechBubblePtr->yaw = -gCameras[gCurrentCameraID].curYaw;
    SpeechBubblePtr->brightness = 255;
}

Referenced by check_for_conversation_prompt().

◆ pulse_stone_notification_setup()

void pulse_stone_notification_setup ( void )

Definition at line 71 of file pulse_stone.c.

                                          {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    mem_clear(PulseStonePtr, sizeof(*PulseStonePtr));
    PulseStonePtr->pos.x = playerStatus->pos.x;
    PulseStonePtr->pos.y = playerStatus->pos.y + playerStatus->colliderHeight + 8.0f;
    PulseStonePtr->pos.z = playerStatus->pos.z;
    playerStatus->animFlags |= PA_FLAG_PULSE_STONE_VISIBLE;
    PulseStoneNotificationCallback = pulse_stone_notification_update;
}

Referenced by check_for_pulse_stone().

◆ appendGfx_speech_bubble()

void appendGfx_speech_bubble ( void )

Definition at line 48 of file speech_bubble.c.

                                   {
    ImgFXTexture ifxImg;
    Matrix4f mtxTemp, mtxTransform;
 
    if (gPlayerStatus.animFlags & PA_FLAG_SPEECH_PROMPT_AVAILABLE) {
        guScaleF(mtxTemp, SpeechBubblePtr->scale, SpeechBubblePtr->scale, SpeechBubblePtr->scale);
        guRotateF(mtxTransform, SpeechBubblePtr->yaw - gCameras[gCurrentCameraID].curYaw, 0.0f, 1.0f, 0.0f);
        guMtxCatF(mtxTemp, mtxTransform, mtxTemp);
        guTranslateF(mtxTransform, SpeechBubblePtr->pos.x, SpeechBubblePtr->pos.y, SpeechBubblePtr->pos.z);
        guMtxCatF(mtxTemp, mtxTransform, mtxTransform);
        guMtxF2L(mtxTransform, &gDisplayContext->matrixStack[gMatrixListPos]);
 
        gSPMatrix(gMainGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++],
                  G_MTX_PUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
        gSPDisplayList(gMainGfxPos++, &speech_bubble_gfx);
 
        ifxImg.raster  = speech_bubble_img;
        ifxImg.palette = speech_bubble_pal;
        ifxImg.width   = speech_bubble_img_width;
        ifxImg.height  = speech_bubble_img_height;
        ifxImg.xOffset = -16;
        ifxImg.yOffset = 26;
        ifxImg.alpha = 255;
        imgfx_update(0, IMGFX_CLEAR, 0, 0, 0, 0, IMGFX_FLAG_400 | IMGFX_FLAG_40);
        imgfx_update(0, IMGFX_SET_COLOR,
                    SpeechBubblePtr->brightness, SpeechBubblePtr->brightness, SpeechBubblePtr->brightness, 255, 0x440);
        imgfx_appendGfx_component(0, &ifxImg, IMGFX_FLAG_40, mtxTransform);
 
        gSPPopMatrix(gMainGfxPos++, G_MTX_MODELVIEW);
    }
}

Referenced by render_conversation_prompt().

◆ appendGfx_pulse_stone_icon()

void appendGfx_pulse_stone_icon ( void )

Definition at line 82 of file pulse_stone.c.

                                      {
    PlayerStatus* playerStatus = &gPlayerStatus;
    Matrix4f sp18, sp58;
    ImgFXTexture ifxImg;
    s32 pingDelay;
    s32 dx, dy;
 
    if (playerStatus->animFlags & PA_FLAG_PULSE_STONE_VISIBLE) {
        guScaleF(sp18, PulseStonePtr->scale, PulseStonePtr->scale, PulseStonePtr->scale);
        guRotateF(sp58, -gCameras[gCurrentCameraID].curYaw, 0.0f, 1.0f, 0.0f);
        guMtxCatF(sp18, sp58, sp18);
        guTranslateF(sp58, PulseStonePtr->pos.x, PulseStonePtr->pos.y, PulseStonePtr->pos.z);
        guMtxCatF(sp18, sp58, sp58);
        guMtxF2L(sp58, &gDisplayContext->matrixStack[gMatrixListPos]);
 
        gSPMatrix(gMainGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++],
                    G_MTX_PUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
        gSPDisplayList(gMainGfxPos++, pulse_stone_icon_gfx);
 
        dx = abs((gGameStatusPtr->mapID % 7) - 2);
        dy = gGameStatusPtr->mapID / 7;
 
        switch (dx + dy) {
            case 0:
                pingDelay = 4;
                break;
            case 1:
                pingDelay = 8;
                break;
            case 2:
                pingDelay = 16;
                break;
            case 3:
                pingDelay = 32;
                break;
            case 4:
                pingDelay = 64;
                break;
            case 5:
                pingDelay = 128;
                break;
            default:
                pingDelay = -1;
                PulseStonePtr->pingTime = 0;
                break;
        }
 
        ifxImg.palette = pulse_stone_icon_1_pal;
        if (pingDelay >= 0) {
            PulseStonePtr->pingTime++;
            if (PulseStonePtr->pingTime >= pingDelay + 2) {
                PulseStonePtr->pingTime = 0;
                sfx_play_sound_at_player(SOUND_PULSE_STONE, SOUND_SPACE_DEFAULT);
            }
            if (PulseStonePtr->pingTime < 2) {
                ifxImg.palette = pulse_stone_icon_2_pal;
            } else {
                ifxImg.palette = pulse_stone_icon_1_pal;
            }
        }
 
        ifxImg.raster  = pulse_stone_icon_img;
        ifxImg.width   = pulse_stone_icon_img_width;
        ifxImg.height  = pulse_stone_icon_img_height;
        ifxImg.xOffset = -28;
        ifxImg.yOffset = 46;
        ifxImg.alpha = 255;
        imgfx_appendGfx_component(0, &ifxImg, 0, sp58);
        gSPPopMatrix(gMainGfxPos++, G_MTX_MODELVIEW);
    }
}

Referenced by render_pulse_stone_icon().

◆ ispy_notification_setup()

void ispy_notification_setup ( void )

Definition at line 91 of file i_spy.c.

                                   {
    mem_clear(ISpyPtr, sizeof(*ISpyPtr));
 
    ISpyPtr->pos.x = gPlayerStatus.pos.x;
    ISpyPtr->pos.y = gPlayerStatus.pos.y + gPlayerStatus.colliderHeight + 8.0f;
    ISpyPtr->pos.z = gPlayerStatus.pos.z;
 
    ISpyPtr->alpha = 255;
 
    gPlayerStatus.animFlags |= PA_FLAG_ISPY_VISIBLE;
    ISpyNotificationCallback = &ispy_notification_update;
}

Referenced by check_for_ispy().

◆ initialize_curtains()

void initialize_curtains ( void )

Definition at line 212 of file curtains.c.

                               {
    gCurtainDrawCallback = NULL;
    gCurtainScale = 2.0f;
    gCurtainScaleGoal = 2.0f;
    gCurtainFade = 0.0f;
    gCurtainFadeGoal = 0.0f;
}

Referenced by load_engine_data(), and state_step_startup().

◆ update_curtains()

void update_curtains ( void )

Definition at line 220 of file curtains.c.

220 {

221}

Referenced by step_game_loop().

◆ set_curtain_scale_goal()

void set_curtain_scale_goal ( f32 scale )

Definition at line 285 of file curtains.c.

                                       {
    gCurtainScaleGoal = scale;
}

Referenced by btl_state_update_normal_start(), state_init_intro(), state_step_exit_file_select(), and state_step_logos().

◆ set_curtain_scale()

void set_curtain_scale ( f32 scale )

Definition at line 289 of file curtains.c.

                                  {
    gCurtainScaleGoal = scale;
    gCurtainScale = scale;
}

Referenced by state_step_logos(), state_step_startup(), and state_step_title_screen().

◆ set_curtain_draw_callback()

void set_curtain_draw_callback ( void(*)(void) callback )

Referenced by state_step_intro(), and state_step_logos().

◆ set_curtain_fade_goal()

void set_curtain_fade_goal ( f32 fade )

Definition at line 298 of file curtains.c.

                                     {
    gCurtainFadeGoal = fade;
}

Referenced by state_init_intro(), state_step_intro(), and state_step_logos().

◆ set_curtain_fade()

void set_curtain_fade ( f32 fade )

Definition at line 302 of file curtains.c.

                                {
    gCurtainFadeGoal = fade;
    gCurtainFade = fade;
}

Referenced by state_step_logos(), state_step_startup(), and state_step_title_screen().

◆ crash_screen_init()

void crash_screen_init ( void )

Definition at line 455 of file crash_screen.c.

                             {
    gCrashScreen.width = SCREEN_WIDTH;
    gCrashScreen.height = 16;
    gCrashScreen.frameBuf = (u16*)((osMemSize | 0xA0000000) - ((SCREEN_WIDTH * SCREEN_HEIGHT) * 2));
    osCreateMesgQueue(&gCrashScreen.queue, &gCrashScreen.mesg, 1);
    osCreateThread(&gCrashScreen.thread, 2, crash_screen_thread_entry, NULL,
                   gCrashScreen.stack + sizeof(gCrashScreen.stack), 0x80);
    osStartThread(&gCrashScreen.thread);
 
    // gCrashScreencharToGlyph is hard to modify, so we'll just do it here
    u8 chars[] =
        "_[]<>"
        "|{};,"
        "\"#$&'"
        "/=@\\`"
        "abcde"
        "fghij"
        "klmno"
        "pqrst"
        "uvwxy"
        "z";
    s32 i;
    for (i = 0; i < ARRAY_COUNT(chars); i++) {
        gCrashScreencharToGlyph[chars[i]] = GLYPH(0, 9) + i;
    }
}

Referenced by boot_main().

◆ crash_screen_set_draw_info()

void crash_screen_set_draw_info	(	u16 *	frameBufPtr,
		s16	width,
		s16	height )

Definition at line 449 of file crash_screen.c.

                                                                         {
    gCrashScreen.frameBuf = (u16*)((u32)frameBufPtr | 0xA0000000);
    gCrashScreen.width = width;
    gCrashScreen.height = height;
}

Referenced by gfx_draw_frame().

◆ basic_ai_wander_init()

void basic_ai_wander_init	(	Evt *	script,
		MobileAISettings *	npcAISettings,
		EnemyDetectVolume *	territory )

Definition at line 567 of file 23680.c.

                                                                                                      {
    Enemy* enemy = script->owner1.enemy;
    Npc* npc = get_npc_unsafe(enemy->npcID);
 
    // chose a random direction and move time
    npc->duration = (npcAISettings->moveTime / 2) + rand_int((npcAISettings->moveTime / 2) + 1);
    npc->yaw = clamp_angle(npc->yaw + rand_int(60) - 30.0f);
    npc->curAnim = enemy->animList[ENEMY_ANIM_INDEX_WALK];
    script->functionTemp[1] = 0;
 
    if (enemy->territory->wander.moveSpeedOverride < 0) {
        npc->moveSpeed = npcAISettings->moveSpeed;
    } else {
        npc->moveSpeed = enemy->territory->wander.moveSpeedOverride / 32767.0;
    }
 
    enemy->aiFlags &= ~AI_FLAG_NEEDS_HEADING;
    enemy->aiFlags &= ~AI_FLAG_OUTSIDE_TERRITORY;
    script->AI_TEMP_STATE = AI_STATE_WANDER;
}

Referenced by HoppingAI_HopInit(), and StoneChompAI_HopInit().

◆ basic_ai_wander()

void basic_ai_wander	(	Evt *	script,
		MobileAISettings *	npcAISettings,
		EnemyDetectVolume *	territory )

Definition at line 588 of file 23680.c.

                                                                                              {
    Enemy* enemy = script->owner1.enemy;
    Npc* npc = get_npc_unsafe(enemy->npcID);
    s32 stillWithinTerritory = FALSE;
    f32 x, y, z;
    EffectInstance* sp34;
    f32 yaw;
 
    // search for the player
    if (aiSettings->playerSearchInterval >= 0) {
        if (script->functionTemp[1] <= 0) {
            script->functionTemp[1] = aiSettings->playerSearchInterval;
            if (basic_ai_check_player_dist(territory, enemy, aiSettings->alertRadius, aiSettings->alertOffsetDist, 0)) {
                x = npc->pos.x;
                y = npc->pos.y;
                z = npc->pos.z;
                yaw = atan2(npc->pos.x, npc->pos.z, gPlayerStatusPtr->pos.x, gPlayerStatusPtr->pos.z);
                if (!npc_test_move_simple_with_slipping(npc->collisionChannel, &x, &y, &z, aiSettings->chaseSpeed, yaw, npc->collisionHeight, npc->collisionDiameter)) {
                    npc->yaw = yaw;
                    ai_enemy_play_sound(npc, SOUND_AI_ALERT_A, SOUND_PARAM_MORE_QUIET);
                    fx_emote(EMOTE_EXCLAMATION, npc, 0, npc->collisionHeight, 1.0f, 2.0f, -20.0f, 15, &sp34);
                    enemy->aiFlags &= ~AI_FLAG_NEEDS_HEADING;
                    enemy->aiFlags &= ~AI_FLAG_OUTSIDE_TERRITORY;
 
                    if (enemy->npcSettings->actionFlags & AI_ACTION_JUMP_WHEN_SEE_PLAYER) {
                        script->AI_TEMP_STATE = AI_STATE_ALERT_INIT;
                    } else {
                        script->AI_TEMP_STATE = AI_STATE_CHASE_INIT;
                    }
                    return;
                }
            }
        }
        script->functionTemp[1]--;
    }
 
    // check if we've wandered beyond the boundary of the territory
    if (is_point_outside_territory(enemy->territory->wander.wanderShape,
                               enemy->territory->wander.centerPos.x,
                               enemy->territory->wander.centerPos.z,
                               npc->pos.x,
                               npc->pos.z,
                               enemy->territory->wander.wanderSize.x,
                               enemy->territory->wander.wanderSize.z)
        && npc->moveSpeed < dist2D(enemy->territory->wander.centerPos.x, enemy->territory->wander.centerPos.z, npc->pos.x, npc->pos.z)
    ) {
        if (!(enemy->aiFlags & AI_FLAG_OUTSIDE_TERRITORY)) {
            enemy->aiFlags |= (AI_FLAG_OUTSIDE_TERRITORY | AI_FLAG_NEEDS_HEADING);
        }
 
        if (enemy->aiFlags & AI_FLAG_NEEDS_HEADING) {
            npc->yaw = clamp_angle(atan2(npc->pos.x, npc->pos.z, enemy->territory->wander.centerPos.x, enemy->territory->wander.centerPos.z));
            enemy->aiFlags &= ~AI_FLAG_NEEDS_HEADING;
        }
 
        // if current heading is deflected by a wall, recalculate yaw to continue pursuing centerPos
        x = npc->pos.x;
        y = npc->pos.y;
        z = npc->pos.z;
        if (npc_test_move_simple_with_slipping(npc->collisionChannel, &x, &y, &z, 2.0 * npc->moveSpeed, npc->yaw, npc->collisionHeight, npc->collisionDiameter)) {
            yaw = clamp_angle(atan2(npc->pos.x, npc->pos.z, enemy->territory->wander.centerPos.x, enemy->territory->wander.centerPos.z));
            enemy->aiFlags &= ~AI_FLAG_NEEDS_HEADING;
            ai_check_fwd_collisions(npc, 5.0f, &yaw, NULL, NULL, NULL);
            npc->yaw = yaw;
        }
        stillWithinTerritory = TRUE;
    } else if (enemy->aiFlags & AI_FLAG_OUTSIDE_TERRITORY) {
        enemy->aiFlags &= ~AI_FLAG_OUTSIDE_TERRITORY;
        enemy->aiFlags &= ~AI_FLAG_NEEDS_HEADING;
    }
 
    // perform the motion
    if (enemy->territory->wander.wanderSize.x | enemy->territory->wander.wanderSize.z | stillWithinTerritory) {
        if (!npc->turnAroundYawAdjustment) {
            npc_move_heading(npc, npc->moveSpeed, npc->yaw);
        } else {
            return;
        }
    }
 
    // decide to loiter or continue wandering
    if (aiSettings->moveTime > 0) {
        npc->duration--;
        if (npc->duration <= 0) {
            script->AI_TEMP_STATE = AI_STATE_LOITER_INIT;
            script->functionTemp[1] = rand_int(1000) % 3 + 2;
            if (aiSettings->unk_AI_2C <= 0 || aiSettings->waitTime <= 0) {
                script->AI_TEMP_STATE = AI_STATE_WANDER_INIT;
            }
        }
    }
}

◆ basic_ai_loiter()

void basic_ai_loiter	(	Evt *	script,
		MobileAISettings *	npcAISettings,
		EnemyDetectVolume *	territory )

Definition at line 691 of file 23680.c.

                                                                                              {
    Enemy* enemy = script->owner1.enemy;
    Npc* npc = get_npc_unsafe(enemy->npcID);
    f32 x, y, z;
    f32 yaw;
    EffectInstance* emoteTemp;
 
    if (aiSettings->playerSearchInterval >= 0) {
        if (basic_ai_check_player_dist(territory, enemy, aiSettings->chaseRadius, aiSettings->chaseOffsetDist, 0)) {
            x = npc->pos.x;
            y = npc->pos.y;
            z = npc->pos.z;
            yaw = atan2(npc->pos.x, npc->pos.z, gPlayerStatusPtr->pos.x, gPlayerStatusPtr->pos.z);
            if (!npc_test_move_simple_with_slipping(npc->collisionChannel, &x, &y, &z, aiSettings->chaseSpeed, yaw, npc->collisionHeight, npc->collisionDiameter)) {
                npc->yaw = yaw;
                ai_enemy_play_sound(npc, SOUND_AI_ALERT_A, SOUND_PARAM_MORE_QUIET);
                fx_emote(EMOTE_EXCLAMATION, npc, 0, npc->collisionHeight, 1.0f, 2.0f, -20.0f, 15, &emoteTemp);
                if (enemy->npcSettings->actionFlags & AI_ACTION_JUMP_WHEN_SEE_PLAYER) {
                    script->AI_TEMP_STATE = AI_STATE_ALERT_INIT;
                } else {
                    script->AI_TEMP_STATE = AI_STATE_CHASE_INIT;
                }
                return;
            }
        }
    }
 
    // look around randomly
    if (npc->turnAroundYawAdjustment == 0) {
        npc->duration--;
        if (npc->duration <= 0) {
            script->functionTemp[1]--;
            if (script->functionTemp[1]) {
                if (!(enemy->npcSettings->actionFlags & AI_ACTION_LOOK_AROUND_DURING_LOITER)) {
                    npc->yaw = clamp_angle(npc->yaw + 180.0f);
                }
                npc->duration = (aiSettings->waitTime / 2) + rand_int(aiSettings->waitTime / 2 + 1);
                return;
            }
            script->AI_TEMP_STATE = AI_STATE_WANDER_INIT;
        }
    }
}

◆ basic_ai_found_player_jump_init()

void basic_ai_found_player_jump_init	(	Evt *	script,
		MobileAISettings *	npcAISettings,
		EnemyDetectVolume *	territory )

Definition at line 735 of file 23680.c.

                                                                                                                 {
    Enemy* enemy = script->owner1.enemy;
    Npc* npc = get_npc_unsafe(enemy->npcID);
 
    ai_enemy_play_sound(npc, SOUND_AI_FOUND_PLAYER_JUMP, 0);
    npc->curAnim = enemy->animList[ENEMY_ANIM_INDEX_JUMP];
    npc->jumpVel = 10.0f;
    npc->jumpScale = 2.5f;
    npc->moveToPos.y = npc->pos.y;
    npc->flags |= NPC_FLAG_JUMPING;
    script->AI_TEMP_STATE = AI_STATE_ALERT;
}

◆ basic_ai_found_player_jump()

void basic_ai_found_player_jump	(	Evt *	script,
		MobileAISettings *	npcAISettings,
		EnemyDetectVolume *	territory )

Definition at line 748 of file 23680.c.

                                                                                                            {
    Npc* npc = get_npc_unsafe(script->owner1.enemy->npcID);
    s32 done = FALSE;
 
    if (npc->jumpVel <= 0.0) {
        if (npc->pos.y <= npc->moveToPos.y) {
            npc->pos.y = npc->moveToPos.y;
            done = TRUE;
        }
    }
 
    if (!done) {
        npc->pos.y += npc->jumpVel;
        npc->jumpVel -= npc->jumpScale;
    } else {
        npc->jumpVel = 0.0f;
        npc->flags &= ~NPC_FLAG_JUMPING;
        script->AI_TEMP_STATE = AI_STATE_CHASE_INIT;
    }
}

◆ basic_ai_chase_init()

void basic_ai_chase_init	(	Evt *	script,
		MobileAISettings *	npcAISettings,
		EnemyDetectVolume *	territory )

Definition at line 769 of file 23680.c.

                                                                                                     {
    Enemy* enemy = script->owner1.enemy;
    Npc* npc = get_npc_unsafe(enemy->npcID);
    s32 skipTurnAround = FALSE;
 
    if ((gPlayerStatusPtr->actionState == ACTION_STATE_JUMP || gPlayerStatusPtr->actionState == ACTION_STATE_BOUNCE ||
        gPlayerStatusPtr->actionState == ACTION_STATE_HOP || gPlayerStatusPtr->actionState == ACTION_STATE_FALLING) &&
        (f64)dist2D(npc->pos.x, npc->pos.z, gPlayerStatusPtr->pos.x, gPlayerStatusPtr->pos.z) < npc->collisionDiameter)
    {
        skipTurnAround = TRUE;
    }
 
    if (!skipTurnAround) {
        f32 angle = atan2(npc->pos.x, npc->pos.z, gPlayerStatusPtr->pos.x, gPlayerStatusPtr->pos.z);
        f32 deltaAngleToPlayer = get_clamped_angle_diff(npc->yaw, angle);
 
        if (npcAISettings->chaseTurnRate < fabsf(deltaAngleToPlayer)) {
            angle = npc->yaw;
            if (deltaAngleToPlayer < 0.0f) {
                angle += -npcAISettings->chaseTurnRate;
            } else {
                angle += npcAISettings->chaseTurnRate;
            }
        }
        npc->yaw = clamp_angle(angle);
        npc->duration = (npcAISettings->chaseUpdateInterval / 2) + rand_int((npcAISettings->chaseUpdateInterval / 2) + 1);
    } else {
        npc->duration = 0;
    }
 
    npc->curAnim = enemy->animList[ENEMY_ANIM_INDEX_CHASE];
    npc->moveSpeed = npcAISettings->chaseSpeed;
    script->AI_TEMP_STATE = AI_STATE_CHASE;
}

Referenced by HoppingAI_ChaseInit(), and StoneChompAI_ChaseInit().

◆ basic_ai_chase()

void basic_ai_chase	(	Evt *	script,
		MobileAISettings *	npcAISettings,
		EnemyDetectVolume *	territory )

Definition at line 804 of file 23680.c.

                                                                                             {
    Enemy* enemy = script->owner1.enemy;
    Npc* npc = get_npc_unsafe(enemy->npcID);
    EffectInstance* sp28;
    f32 x, y, z;
 
    if (!basic_ai_check_player_dist(territory, enemy, aiSettings->chaseRadius, aiSettings->chaseOffsetDist, 1)) {
        fx_emote(EMOTE_QUESTION, npc, 0, npc->collisionHeight, 1.0f, 2.0f, -20.0f, 15, &sp28);
        npc->curAnim = enemy->animList[ENEMY_ANIM_INDEX_IDLE];
        npc->duration = 20;
        script->AI_TEMP_STATE = AI_STATE_LOSE_PLAYER;
        return;
    }
 
    if (enemy->npcSettings->actionFlags & AI_ACTION_04) {
        if (dist2D(npc->pos.x, npc->pos.z, gPlayerStatusPtr->pos.x, gPlayerStatusPtr->pos.z) > (npc->moveSpeed * 5.0)) {
            x = npc->pos.x;
            y = npc->pos.y;
            z = npc->pos.z;
            if (npc_test_move_simple_with_slipping(npc->collisionChannel, &x, &y, &z, 1.0f, npc->yaw, npc->collisionHeight, npc->collisionDiameter)) {
                fx_emote(EMOTE_QUESTION, npc, 0, npc->collisionHeight, 1.0f, 2.0f, -20.0f, 0xC, &sp28);
                npc->curAnim = enemy->animList[ENEMY_ANIM_INDEX_IDLE];
                npc->duration = 15;
                script->AI_TEMP_STATE = AI_STATE_LOSE_PLAYER;
                return;
            }
        }
    }
 
    npc_surface_spawn_fx(npc, SURFACE_INTERACT_RUN);
    npc_move_heading(npc, npc->moveSpeed, npc->yaw);
 
    if (npc->moveSpeed > 8.0 && !(gGameStatusPtr->frameCounter % 5)) {
        ai_enemy_play_sound(npc, SOUND_SMALL_NPC_STEP, 0);
    }
 
    if (npc->duration > 0) {
        npc->duration--;
    } else {
        script->AI_TEMP_STATE = AI_STATE_CHASE_INIT;
    }
}

◆ basic_ai_lose_player()

void basic_ai_lose_player	(	Evt *	script,
		MobileAISettings *	npcAISettings,
		EnemyDetectVolume *	territory )

Definition at line 847 of file 23680.c.

                                                                                                      {
    Enemy* enemy = script->owner1.enemy;
    Npc* npc = get_npc_unsafe(enemy->npcID);
 
    npc->duration--;
    if (npc->duration == 0) {
        // turn to face home position
        npc->yaw = clamp_angle(atan2(npc->pos.x, npc->pos.z, enemy->territory->wander.centerPos.x, enemy->territory->wander.centerPos.z));
        script->AI_TEMP_STATE = AI_STATE_WANDER_INIT;
    }
}

◆ basic_ai_suspend()

void basic_ai_suspend ( Evt * script )

Definition at line 13 of file 25AF0.c.

                                   {
    Enemy* enemy = script->owner1.enemy;
 
    get_npc_unsafe(enemy->npcID);
    if (enemy->aiSuspendTime == 0) {
        script->functionTemp[0] = script->functionTemp[1];
    }
}

◆ create_worker_scene()

s32 create_worker_scene	(	void(*)(void)	updateFunc,
		void(*)(void)	renderFunc )

Definition at line 32 of file worker.c.

                                                                            {
    Worker* worker;
    s32 i;
 
    for (i = 0; i < MAX_WORKERS; i++) {
        Worker* lastWorker = (*gCurrentWorkerListPtr)[i];
        if (lastWorker == NULL) {
            break;
        }
    }
    ASSERT(i < MAX_WORKERS);
 
    (*gCurrentWorkerListPtr)[i] = worker = heap_malloc(sizeof(*worker));
    ASSERT(worker != NULL);
 
    worker->flags = WORKER_FLAG_1 | WORKER_FLAG_SKIP_DRAW_UNTIL_UPDATE;
    worker->update = updateFunc;
    if (updateFunc == NULL) {
        worker->update = worker_delegate_do_nothing;
    }
    worker->draw = renderFunc;
    if (renderFunc == NULL) {
        worker->draw = worker_delegate_do_nothing;
    }
 
    if (gGameStatusPtr->context != CONTEXT_WORLD) {
        i |= BATTLE_ENTITY_ID_BIT;
    }
    return i;
}

Referenced by clear_encounter_status(), clear_item_entity_data(), clear_virtual_entity_list(), func_80045AC0(), init_encounter_status(), initialize_battle(), and reset_model_animators().

◆ init_entity_models()

void init_entity_models ( void )

Definition at line 74 of file entity_model.c.

                              {
    s32 i;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentEntityModelList = &gWorldEntityModelList;
    } else {
        gCurrentEntityModelList = &gBattleEntityModelList;
    }
 
    gEntityModelCount = 0;
    entity_fog_enabled = 0;
    entity_fog_red = 10;
    entity_fog_green = 10;
    entity_fog_blue = 10;
    entity_fog_alpha = 10;
    entity_fog_dist_min = 800;
    entity_fog_dist_max = 1000;
}

Referenced by state_step_end_battle(), and state_step_unpause().

◆ phys_get_spin_history()

f32 phys_get_spin_history	(	s32	lag,
		s32 *	x,
		s32 *	y,
		s32 *	z )

Definition at line 82 of file 7E9D0.c.

                                                           {
    s32 idx = gSpinHistoryBufferPos - lag;
 
    if (idx < 0) {
        idx += ARRAY_COUNT(gSpinHistoryPosAngle);
    }
 
    *x = gSpinHistoryPosX[idx];
    *y = gSpinHistoryPosY[idx];
    *z = gSpinHistoryPosZ[idx];
    return gSpinHistoryPosAngle[idx];
}

Referenced by appendGfx_player_spin().

◆ imgfx_update()

void imgfx_update	(	u32	idx,
		ImgFXType	type,
		s32	imgfxArg1,
		s32	imgfxArg2,
		s32	imgfxArg3,
		s32	imgfxArg4,
		s32	flags )

Definition at line 486 of file imgfx.c.

                                                                                                                  {
    ImgFXState* state = &(*ImgFXInstances)[idx];
    s32 oldFlags;
    u8 r, g, b, a;
 
    if (!(state->flags & IMGFX_FLAG_VALID) || (idx >= MAX_IMGFX_INSTANCES)) {
        return;
    }
 
    switch (type) {
        case IMGFX_CLEAR:
        case IMGFX_RESET:
            oldFlags = state->flags;
            imgfx_cache_instance_data(state);
            imgfx_init_instance(state);
            state->flags = oldFlags;
            state->lastAnimCmd = IMGFX_CLEAR;
            state->lastColorCmd = IMGFX_CLEAR;
            state->meshType = IMGFX_MESH_DEFAULT;
            state->renderType = IMGFX_RENDER_DEFAULT;
            state->ints.raw[0][0] = -1;
            state->ints.raw[1][0] = -1;
 
            state->flags &= IMGFX_FLAG_VALID;
            if (flags != 0) {
                state->flags |= flags;
            } else {
                state->flags |= 0; // required to match
            }
            return;
        case IMGFX_UNK_1:
            state->lastAnimCmd = IMGFX_CLEAR;
            state->renderType = IMGFX_RENDER_DEFAULT;
            state->ints.raw[0][0] = -1;
            return;
        case IMGFX_UNK_2:
            state->lastColorCmd = IMGFX_CLEAR;
            state->meshType = IMGFX_MESH_DEFAULT;
            state->ints.raw[1][0] = -1;
            return;
        case IMGFX_ALLOC_COLOR_BUF:
            if (state->colorBuf != NULL) {
                heap_free(state->colorBuf);
            }
            state->colorBufCount = imgfxArg1 * 4;
            state->colorBuf = heap_malloc(state->colorBufCount);
            return;
        case IMGFX_OVERLAY:
        case IMGFX_OVERLAY_XLU:
            if (type == state->lastColorCmd
                && imgfxArg1 == (s32) state->ints.overlay.pattern
                && imgfxArg2 == state->ints.overlay.alpha
            ) {
                // no paramaters have changed
                return;
            }
            break;
        case IMGFX_SET_ANIM:
            if (state->lastAnimCmd == type
                && state->ints.anim.type == imgfxArg1
                && state->ints.anim.interval == imgfxArg2
                && state->ints.anim.step == imgfxArg3
            ) {
                // no paramaters have changed
                return;
            }
            break;
        default:
            if (type != IMGFX_HOLOGRAM && state->lastColorCmd == IMGFX_HOLOGRAM) {
                state->meshType = IMGFX_MESH_DEFAULT;
                state->subdivX = 1;
                state->subdivY = 1;
            }
            break;
    }
 
    if (type != IMGFX_SET_ANIM && state->lastAnimCmd == IMGFX_SET_ANIM) {
        state->lastAnimCmd = IMGFX_CLEAR;
    }
 
    if (type == IMGFX_SET_WAVY || type == IMGFX_SET_ANIM) {
        state->lastAnimCmd = type;
        state->ints.args.anim[0] = imgfxArg1;
        state->ints.args.anim[1] = imgfxArg2;
        state->ints.args.anim[2] = imgfxArg3;
        state->ints.args.anim[3] = imgfxArg4;
    } else if (type >= IMGFX_SET_COLOR && type <= IMGFX_OVERLAY_XLU) {
        state->lastColorCmd = type;
        state->ints.args.color[0] = imgfxArg1;
        state->ints.args.color[1] = imgfxArg2;
        state->ints.args.color[2] = imgfxArg3;
        state->ints.args.color[3] = imgfxArg4;
    }
 
    state->flags &= IMGFX_FLAG_VALID;
    if (flags != 0) {
        state->flags |= flags;
    }
    state->meshType = IMGFX_MESH_DEFAULT;
 
    switch (type) {
        case IMGFX_RESET:
            state->meshType = IMGFX_MESH_DEFAULT;
            state->renderType = IMGFX_RENDER_DEFAULT;
            break;
        case IMGFX_SET_WAVY:
            state->subdivX = 4;
            state->subdivY = 4;
            state->meshType = IMGFX_MESH_GRID_WAVY;
            imgfx_wavy_init(state);
            break;
        case IMGFX_SET_ANIM:
            state->meshType = IMGFX_MESH_ANIMATED;
            state->renderType = IMGFX_RENDER_ANIM;
            state->floats.anim.curFrame = 0.0f;
            state->floats.anim.curIdx = 0.0f;
            state->flags |= IMGFX_FLAG_200;
            break;
        case IMGFX_SET_COLOR:
        case IMGFX_SET_ALPHA:
        case IMGFX_SET_TINT:
            if (imgfxArg1 >= 255 && imgfxArg2 >= 255 && imgfxArg3 >= 255 && imgfxArg4 >= 255) {
                // no color + no transparency
                state->renderType = IMGFX_RENDER_DEFAULT;
            } else if (imgfxArg4 >= 255) {
                // some color + no transparency
                state->renderType = IMGFX_RENDER_MULTIPLY_RGB;
            } else if (imgfxArg1 >= 255 && imgfxArg2 >= 255 && imgfxArg3 >= 255) {
                // no color + transparency
                state->renderType = IMGFX_RENDER_MULTIPLY_ALPHA;
            } else {
                // some color + transparency
                state->renderType = IMGFX_RENDER_MULTIPLY_RGBA;
            }
            break;
        case IMGFX_SET_WHITE_FADE:
        case IMGFX_SET_CREDITS_FADE:
            if (imgfxArg4 == 255.0) {
                state->renderType = IMGFX_RENDER_MODULATE_PRIM_RGB;
            } else {
                state->renderType = IMGFX_RENDER_MODULATE_PRIM_RGBA;
            }
            break;
        case IMGFX_COLOR_BUF_SET_MULTIPLY:
            if (imgfxArg1 < state->colorBufCount) {
                // unpack and store color
                r = (imgfxArg2 & 0xFF000000) >> 24;
                g = (imgfxArg2 & 0xFF0000) >> 16;
                b = (imgfxArg2 & 0xFF00) >> 8;
                a = (imgfxArg2 & 0xFF);
                state->colorBuf[imgfxArg1].r = r;
                state->colorBuf[imgfxArg1].g = g;
                state->colorBuf[imgfxArg1].b = b;
                state->colorBuf[imgfxArg1].a = a;
 
                state->meshType = IMGFX_MESH_DEFAULT;
 
                if (a == 255) {
                    state->renderType = IMGFX_RENDER_MULTIPLY_SHADE_RGB;
                } else {
                    state->renderType = IMGFX_RENDER_MULTIPLY_SHADE_RGBA;
                }
            }
            break;
        case IMGFX_COLOR_BUF_SET_MODULATE:
            if (imgfxArg1 < state->colorBufCount) {
                // unpack and store color
                r = (imgfxArg2 & 0xFF000000) >> 24;
                g = (imgfxArg2 & 0xFF0000) >> 16;
                b = (imgfxArg2 & 0xFF00) >> 8;
                a = (imgfxArg2 & 0xFF);
                state->colorBuf[imgfxArg1].r = r;
                state->colorBuf[imgfxArg1].g = g;
                state->colorBuf[imgfxArg1].b = b;
                state->colorBuf[imgfxArg1].a = a;
 
                state->meshType = IMGFX_MESH_DEFAULT;
 
                if (a == 255) {
                    state->renderType = IMGFX_RENDER_MODULATE_SHADE_RGB;
                } else {
                    state->renderType = IMGFX_RENDER_MODULATE_SHADE_RGBA;
                }
            }
            break;
        case IMGFX_HOLOGRAM:
            state->renderType = IMGFX_RENDER_HOLOGRAM;
            break;
        case IMGFX_FILL_COLOR:
            state->renderType = IMGFX_RENDER_COLOR_FILL;
            break;
        case IMGFX_OVERLAY:
        case IMGFX_OVERLAY_XLU:
            state->meshType = IMGFX_MESH_STRIP;
            if (imgfxArg2 >= 255) {
                state->renderType = IMGFX_RENDER_OVERLAY_RGB;
            } else {
                state->renderType = IMGFX_RENDER_OVERLAY_RGBA;
            }
            state->floats.overlay.posX = 0.0f;
            state->floats.overlay.posY = 0.0f;
            break;
        case IMGFX_CLEAR:
            break;
    }
}

Referenced by appendGfx_interact_prompt(), appendGfx_ispy_icon(), appendGfx_speech_bubble(), render_hud_element(), set_npc_imgfx_comp(), and set_player_imgfx_comp().

◆ imgfx_appendGfx_component()

s32 imgfx_appendGfx_component	(	s32	idx,
		ImgFXTexture *	ifxImg,
		u32	flagBits,
		Matrix4f	mtx )

Definition at line 703 of file imgfx.c.

                                                                                         {
    ImgFXState* state = &(*ImgFXInstances)[idx];
    s32 ret = 0;
 
    if (ifxImg->alpha == 0) {
        return 0;
    }
 
    state->arrayIdx = idx;
    state->flags |= flagBits;
    ImgFXCurrentTexturePtr->tex.raster  = ifxImg->raster;
    ImgFXCurrentTexturePtr->tex.palette = ifxImg->palette;
    ImgFXCurrentTexturePtr->tex.width   = ifxImg->width;
    ImgFXCurrentTexturePtr->tex.height  = ifxImg->height;
    ImgFXCurrentTexturePtr->tex.xOffset = ifxImg->xOffset;
    ImgFXCurrentTexturePtr->tex.yOffset = ifxImg->yOffset;
    ImgFXCurrentTexturePtr->unk_18  = 0;
    ImgFXCurrentTexturePtr->unk_1E  = 0;
    ImgFXCurrentTexturePtr->alphaMultiplier = ifxImg->alpha;
 
    if (idx < 0 || idx >= MAX_IMGFX_INSTANCES) {
        return 0;
    }
 
    if (idx >= MAX_IMGFX_INSTANCES || state == NULL) {
        return 0;
    }
 
    imgfx_make_mesh(state);
    imgfx_appendGfx_mesh(state, mtx);
 
    if (state->flags & IMGFX_FLAG_ANIM_DONE) {
        state->ints.raw[0][0] = -1;
        state->ints.raw[1][0] = -1;
        state->lastAnimCmd = IMGFX_CLEAR;
        state->meshType = 0;
        state->renderType = IMGFX_RENDER_DEFAULT;
        state->flags &= ~(IMGFX_FLAG_ANIM_DONE | IMGFX_FLAG_800 | IMGFX_FLAG_REVERSE_ANIM | IMGFX_FLAG_LOOP_ANIM);
        imgfx_cache_instance_data(state);
        ret = 1;
    } else if (state->flags & IMGFX_FLAG_4000) {
        ret = 2;
    } else if (state->flags & IMGFX_FLAG_20000) {
        state->lastAnimCmd = IMGFX_CLEAR;
        state->lastColorCmd = IMGFX_CLEAR;
        state->meshType = IMGFX_MESH_DEFAULT;
        state->renderType = IMGFX_RENDER_DEFAULT;
        state->ints.raw[0][0] = -1;
        state->ints.raw[1][0] = -1;
        state->flags &= IMGFX_FLAG_VALID;
        ret = 1;
    }
    return ret;
}

Referenced by appendGfx_entity_model(), appendGfx_interact_prompt(), appendGfx_ispy_icon(), appendGfx_pulse_stone_icon(), appendGfx_speech_bubble(), draw_coin_sparkles(), draw_entity_model_E(), gfx_build_knocked_down_player(), render_hud_element(), and spr_appendGfx_component().

◆ imgfx_update_cache()

void imgfx_update_cache ( void )

Definition at line 332 of file imgfx.c.

                              {
    imgfx_update_cache_impl();
}

Referenced by state_drawUI_world().

◆ imgfx_get_free_instances()

s32 imgfx_get_free_instances ( s32 count )

Definition at line 337 of file imgfx.c.

                                        {
    s32 numAssigned;
    s32 foundAny;
    s32 iPrev;
    s32 firstIdx;
    s32 i;
 
    numAssigned = 0;
    for (i = 1; i < ARRAY_COUNT(*ImgFXInstances); i++) {
        if (!((*ImgFXInstances)[i].flags & IMGFX_FLAG_VALID)) {
            numAssigned++;
        }
    }
 
    if (numAssigned < count) {
        return -1;
    }
 
    firstIdx = 0;
    foundAny = FALSE;
    numAssigned = 0;
    iPrev = -1;
    for (i = 1; i < ARRAY_COUNT(*ImgFXInstances); i++) {
        if ((*ImgFXInstances)[i].flags & IMGFX_FLAG_VALID) {
            continue;
        }
 
        if (!foundAny) {
            firstIdx = i;
            foundAny = TRUE;
        } else {
            (*ImgFXInstances)[iPrev].nextIdx = i;
        }
 
        (*ImgFXInstances)[i].arrayIdx = i;
        imgfx_init_instance(&(*ImgFXInstances)[i]);
        numAssigned++;
        (*ImgFXInstances)[i].flags |= IMGFX_FLAG_VALID;
        iPrev = i;
        if (numAssigned == count) {
            (*ImgFXInstances)[i].nextIdx = -1;
            break;
        }
    }
 
    return firstIdx;
}

Referenced by hud_element_create_transform_A(), spr_load_npc_sprite(), and spr_update_player_sprite().

◆ free_worker()

void free_worker ( s32 idx )

Definition at line 176 of file worker.c.

                          {
    if (gGameStatusPtr->context == CONTEXT_WORLD || (idx & BATTLE_ENTITY_ID_BIT)) {
        idx &= ~BATTLE_ENTITY_ID_BIT;
        if ((*gCurrentWorkerListPtr)[idx] != NULL) {
            heap_free((*gCurrentWorkerListPtr)[idx]);
            (*gCurrentWorkerListPtr)[idx] = NULL;
        }
    }
}

Referenced by popup_menu_update().

◆ ai_check_fwd_collisions()

b32 ai_check_fwd_collisions	(	Npc *	npc,
		f32	time,
		f32 *	outYaw,
		f32 *	outDistFwd,
		f32 *	outDistCW,
		f32 *	outDistCCW )

Definition at line 22 of file 25AF0.c.

                                                                                                               {
    f32 x1, y1, z1;
    f32 x2, y2, z2;
    f32 x3, y3, z3;
    f32 fwdHitDist = -1.0f;
    f32 cwHitDist = -1.0f;
    f32 ccwHitDist = -1.0f;
    f32 yaw;
    b32 fwdHit;
 
    x1 = npc->pos.x;
    y1 = npc->pos.y;
    z1 = npc->pos.z;
    yaw = *outYaw;
 
    fwdHit = npc_test_move_simple_with_slipping(npc->collisionChannel,
            &x1, &y1, &z1,
            npc->moveSpeed * time,
            yaw,
            npc->collisionHeight,
            npc->collisionDiameter);
 
    if (fwdHit) {
        fwdHitDist = dist2D(npc->pos.x, npc->pos.z, x1, z1);
 
        x2 = npc->pos.x;
        y2 = npc->pos.y;
        z2 = npc->pos.z;
        if (npc_test_move_simple_with_slipping(npc->collisionChannel,
                &x2, &y2, &z2, npc->moveSpeed * time,
                clamp_angle(yaw + 35.0f),
                npc->collisionHeight,
                npc->collisionDiameter) != 0) {
            cwHitDist = dist2D(npc->pos.x, npc->pos.z, x2, z2);
        }
 
        x3 = npc->pos.x;
        y3 = npc->pos.y;
        z3 = npc->pos.z;
        if (npc_test_move_simple_with_slipping(npc->collisionChannel,
                &x3, &y3, &z3,
                npc->moveSpeed * time,
                clamp_angle(yaw - 35.0f),
                npc->collisionHeight,
                npc->collisionDiameter) != 0) {
            ccwHitDist = dist2D(npc->pos.x, npc->pos.z, x3, z3);
        }
 
        if ((cwHitDist < fwdHitDist && ccwHitDist < cwHitDist) || (ccwHitDist < fwdHitDist && cwHitDist < ccwHitDist)) {
            yaw = npc->yaw;
        } else if ((fwdHitDist < cwHitDist && ccwHitDist < fwdHitDist) || (ccwHitDist < cwHitDist && fwdHitDist < ccwHitDist)) {
            yaw = npc->yaw + 35.0f;
        } else if ((fwdHitDist < ccwHitDist && cwHitDist < fwdHitDist) || (cwHitDist < ccwHitDist && fwdHitDist < cwHitDist)) {
            yaw = npc->yaw - 35.0f;
        }
    }
 
    if (outYaw != NULL) {
        *outYaw = clamp_angle(yaw);
    }
    if (outDistFwd != NULL) {
        *outDistFwd = fwdHitDist;
    }
    if (outDistCW != NULL) {
        *outDistCW = cwHitDist;
    }
    if (outDistCCW != NULL) {
        *outDistCCW = ccwHitDist;
    }
    return fwdHit;
}

Referenced by basic_ai_wander(), ClubbaNappingAI_ReturnHome(), ShyGuyPatrolAI_15(), ShyGuyPatrolAI_16(), ShyGuyWanderAI_15(), and ShyGuyWanderAI_16().

◆ basic_ai_loiter_init()

void basic_ai_loiter_init	(	Evt *	script,
		MobileAISettings *	aiSettings,
		EnemyDetectVolume *	territory )

Definition at line 681 of file 23680.c.

                                                                                                   {
    Enemy* enemy = script->owner1.enemy;
    Npc* npc = get_npc_unsafe(enemy->npcID);
 
    npc->duration = (aiSettings->waitTime / 2) + rand_int((aiSettings->waitTime / 2) + 1);
    npc->yaw = clamp_angle(npc->yaw + rand_int(180) - 90.0f);
    npc->curAnim = enemy->animList[ENEMY_ANIM_INDEX_IDLE];
    script->AI_TEMP_STATE = AI_STATE_LOITER;
}

◆ PatrolAI_LoiterInit()

void PatrolAI_LoiterInit	(	Evt *	script,
		MobileAISettings *	aiSettings,
		EnemyDetectVolume *	territory )

Definition at line 96 of file States_PatrolAI.inc.c.

                                                                                                     {
    Enemy* enemy = script->owner1.enemy;
    Npc* npc = get_npc_unsafe(enemy->npcID);
 
    npc->duration = (aiSettings->waitTime / 2) + rand_int((aiSettings->waitTime / 2) + 1);
    npc->yaw = clamp_angle(npc->yaw + rand_int(180) - 90.0f);
    npc->curAnim = enemy->animList[ENEMY_ANIM_INDEX_IDLE];
    script->AI_TEMP_STATE = AI_STATE_LOITER;
}

◆ func_80263230()

s32 func_80263230	(	Actor *	actor,
		Actor *	targetActor )

Definition at line 558 of file 190B20.c.

                                                    {
    return func_80263064(actor, targetActor, FALSE);
}

Referenced by btl_state_update_first_strike(), and dispatch_damage_event_actor().

◆ set_part_glow_pal()

void set_part_glow_pal	(	ActorPart *	part,
		s32	glowState )

Definition at line 2642 of file 190B20.c.

                                                       {
    if (part->idleAnimations != NULL && !(part->flags & ACTOR_PART_FLAG_NO_DECORATIONS)) {
        DecorationTable* decorations = part->decorationTable;
 
        if (decorations->glowState != glowState) {
            decorations->glowState = glowState;
            decorations->glowUnk1 = 0;
            decorations->glowStateChanged = TRUE;
        }
    }
}

Referenced by set_actor_glow_pal().

◆ clear_actor_static_pal_adjustments()

void clear_actor_static_pal_adjustments ( Actor * actor )

Definition at line 2624 of file 190B20.c.

                                                      {
    for (ActorPart* part = actor->partsTable; part != NULL; part = part->nextPart) {
        DecorationTable* decorations = part->decorationTable;
 
        if (!(part->flags & ACTOR_PART_FLAG_USE_ABSOLUTE_POSITION)
            && !(part->flags & ACTOR_PART_FLAG_INVISIBLE)
            && (part->idleAnimations != NULL)
            && !(part->flags & ACTOR_PART_FLAG_NO_DECORATIONS)
        ) {
            if (decorations->paletteAdjustment != ACTOR_PAL_ADJUST_BLEND_PALETTES_UNIFORM_INTERVALS
             && decorations->paletteAdjustment != ACTOR_PAL_ADJUST_BLEND_PALETTES_VARYING_INTERVALS
            ) {
                decorations->paletteAdjustment = ACTOR_PAL_ADJUST_NONE;
            }
        }
    }
}

◆ set_actor_flash_mode()

void set_actor_flash_mode	(	Actor *	actor,
		s32	arg1 )

Definition at line 2696 of file 190B20.c.

                                                        {
    for (ActorPart* part = actor->partsTable; part != NULL; part = part->nextPart) {
        if (!(part->flags & (ACTOR_PART_FLAG_INVISIBLE | ACTOR_PART_FLAG_USE_ABSOLUTE_POSITION))
            && part->decorationTable != NULL
            && !(part->flags & ACTOR_PART_FLAG_NO_DECORATIONS)
            && part->idleAnimations != NULL
        ) {
            set_part_flash_mode(part, flashState);
        }
    }
}

Referenced by calc_enemy_damage_target(), calc_item_damage_enemy(), calc_partner_damage_enemy(), calc_player_damage_enemy(), dispatch_damage_event_actor(), dispatch_damage_event_partner(), and dispatch_damage_event_player().

◆ remove_player_buffs()

void remove_player_buffs ( s32 buffs )

Definition at line 2806 of file 190B20.c.

                                    {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* player = battleStatus->playerActor;
    Actor* partner = battleStatus->partnerActor;
    ActorPart* playerActorParts = player->partsTable;
 
    if (buffs & PLAYER_BUFF_JUMP_CHARGE) {
        battleStatus->jumpCharge = 0;
        battleStatus->flags1 &= ~BS_FLAGS1_JUMP_CHARGED;
    }
    if (buffs & PLAYER_BUFF_HAMMER_CHARGE) {
        battleStatus->hammerCharge = 0;
        battleStatus->flags1 &= ~BS_FLAGS1_HAMMER_CHARGED;
    }
    if (buffs & PLAYER_BUFF_STONE) {
        player->stoneDuration = 0;
        player->stoneStatus = 0;
    }
    if (buffs & PLAYER_BUFF_HUSTLE) {
        battleStatus->hustleTurns = 0;
        battleStatus->flags1 &= ~BS_FLAGS1_HUSTLED;
    }
    if (buffs & PLAYER_BUFF_STATIC && (player->staticStatus != 0)) {
        player->staticDuration = 0;
        player->staticStatus = 0;
        remove_status_static(player->hudElementDataIndex);
    }
    if (buffs & PLAYER_BUFF_TRANSPARENT && (player->transparentStatus != 0)) {
        player->transparentDuration = 0;
        player->transparentStatus = 0;
        playerActorParts->flags &= ~ACTOR_PART_FLAG_TRANSPARENT;
        remove_status_transparent(player->hudElementDataIndex);
    }
    if (buffs & PLAYER_BUFF_WATER_BLOCK && (battleStatus->waterBlockTurnsLeft != 0)) {
        battleStatus->waterBlockTurnsLeft = 0;
        battleStatus->buffEffect->data.partnerBuff->unk_0C[FX_BUFF_DATA_WATER_BLOCK].turnsLeft = 0;
        battleStatus->waterBlockEffect->flags |= FX_INSTANCE_FLAG_DISMISS;
 
        fx_water_block(FX_WATER_BLOCK_DESTROY, player->curPos.x, player->curPos.y + 18.0f, player->curPos.z + 5.0f, 1.5f, 10);
        fx_water_splash(0, player->curPos.x - 10.0f, player->curPos.y + 5.0f, player->curPos.z + 5.0f, 1.0f, 24);
        fx_water_splash(0, player->curPos.x - 15.0f, player->curPos.y + 32.0f, player->curPos.z + 5.0f, 1.0f, 24);
        fx_water_splash(1, player->curPos.x + 15.0f, player->curPos.y + 22.0f, player->curPos.z + 5.0f, 1.0f, 24);
 
        battleStatus->waterBlockEffect = NULL;
        sfx_play_sound(SOUND_DESTROY_WATER_BLOCK);
    }
    if (buffs & PLAYER_BUFF_TURBO_CHARGE && (battleStatus->turboChargeTurnsLeft != 0)) {
        battleStatus->turboChargeTurnsLeft = 0;
        battleStatus->buffEffect->data.partnerBuff->unk_0C[FX_BUFF_DATA_TURBO_CHARGE].turnsLeft = 0;
    }
    if (buffs & PLAYER_BUFF_CLOUD_NINE && (battleStatus->cloudNineTurnsLeft != 0)) {
        battleStatus->cloudNineTurnsLeft = 0;
        battleStatus->buffEffect->data.partnerBuff->unk_0C[FX_BUFF_DATA_CLOUD_NINE].turnsLeft = 0;
        remove_effect(battleStatus->cloudNineEffect);
        battleStatus->cloudNineEffect = NULL;
    }
 
    if (partner != NULL && (buffs & PLAYER_BUFF_PARTNER_GLOWING)) {
        partner->isGlowing = FALSE;
        gBattleStatus.flags1 &= ~BS_FLAGS1_GOOMBARIO_CHARGED;
    }
}

◆ is_actor_health_bar_visible()

s32 is_actor_health_bar_visible ( Actor * actor )

Definition at line 503 of file 181810.c.

                                              {
    BattleStatus* battleStatus = &gBattleStatus;
    s32 flags;
 
    if (is_ability_active(ABILITY_PEEKABOO)) {
        return TRUE;
    }
 
    flags = get_global_byte(EVT_INDEX_OF_GAME_BYTE(GB_Tattles_00) + actor->actorType / 8);
    if (actor->flags & ACTOR_FLAG_TYPE_CHANGED) {
        flags |= battleStatus->tattleFlags[actor->actorType / 8];
    }
 
    return (flags >> (actor->actorType % 8)) & 1;
}

Referenced by btl_draw_enemy_health_bars().

◆ sin_cos_rad()

void sin_cos_rad	(	f32	rad,
		f32 *	outSinTheta,
		f32 *	outCosTheta )

Definition at line 705 of file 43F0.c.

                                                                {
    u16 binang = _wrap_trig_lookup_value(RAD_TO_BINANG(theta));
 
    *outSinTheta = sins(binang) * SHT_MINV;
    *outCosTheta = coss(binang) * SHT_MINV;
}

Referenced by action_hammer_end_swing(), action_hammer_test_swing_collision(), action_update_hit_fire(), action_update_hit_lava(), action_update_knockback(), action_update_sliding(), action_update_state_23(), action_update_step_up(), action_update_use_spinning_flower(), action_update_use_tweester(), add_vec2D_polar(), collision_main_lateral(), entity_GiantChest_open(), entity_PinkFlowerLight_setupGfx(), entity_shattering_idle(), npc_surface_spawn_basic_fx(), npc_surface_spawn_cloud_fx(), npc_surface_spawn_flower_fx(), npc_surface_spawn_hedges_fx(), npc_surface_spawn_snow_fx(), npc_surface_spawn_water_fx(), npc_test_move_with_slipping(), npc_test_move_without_slipping(), peach_disguise_check_overlaps(), player_raycast_below(), player_surface_spawn_basic_fx(), player_surface_spawn_cloud_fx(), player_surface_spawn_flower_fx(), player_surface_spawn_hedges_fx(), player_surface_spawn_snow_fx(), player_surface_spawn_water_fx(), player_test_lateral_overlap(), player_test_move_with_slipping(), player_test_move_without_slipping(), test_ray_collider_horizontal(), test_ray_to_wall_center(), update_riding_physics(), and update_riding_physics().

◆ load_font()

void load_font ( s32 font )

Definition at line 225 of file msg.c.

                         {
    if (font != D_80155C98) {
        if (font == 0) {
#if VERSION_JP
            load_font_data(charset_kana_OFFSET, 0x5710, MsgCharImgKana);
            load_font_data(charset_latin_OFFSET, 0xBD0, MsgCharImgLatin);
            load_font_data(charset_kanji_OFFSET, 0x34F0, MsgCharImgTitle); // huh
            load_font_data(charset_buttons_OFFSET, 0x460, MsgCharImgSubtitle); // what
            load_font_data(charset_menu_kana_OFFSET, 0x37F8, MsgCharImgMenuKana);
            load_font_data(charset_menu_latin_OFFSET, 0x798, MsgCharImgMenuLatin);
#else
            load_font_data(charset_standard_OFFSET, 0x5100, MsgCharImgNormal);
#endif
            load_font_data(charset_standard_pal_OFFSET, 0x500, D_802F4560);
        } else if (font == 1) {
            load_font_data(charset_title_OFFSET, 0xF60, MsgCharImgTitle);
            load_font_data(charset_subtitle_OFFSET, 0xB88, MsgCharImgSubtitle);
            load_font_data(charset_subtitle_pal_OFFSET, 0x80, D_802F4560);
        }
    }
}

Referenced by clear_printers().

◆ load_font_data()

void load_font_data	(	Addr	offset,
		u16	size,
		void *	dest )

Definition at line 218 of file msg.c.

                                                       {
#endif
    u8* base = charset_ROM_START + (s32) offset;
 
    dma_copy(base, base + size, dest);
}

Referenced by filemenu_draw_char(), load_font(), and msg_draw_char().

◆ load_asset_by_name()

void * load_asset_by_name	(	const char *	assetName,
		u32 *	decompressedSize )

Definition at line 251 of file world.c.

                                                                       {
    AssetHeader firstHeader;
    AssetHeader* assetTableBuffer;
    AssetHeader* curAsset;
    void* ret;
 
    dma_copy((u8*) ASSET_TABLE_FIRST_ENTRY, (u8*) ASSET_TABLE_FIRST_ENTRY + sizeof(AssetHeader), &firstHeader);
    assetTableBuffer = heap_malloc(firstHeader.offset);
    curAsset = &assetTableBuffer[0];
    dma_copy((u8*) ASSET_TABLE_FIRST_ENTRY, (u8*) ASSET_TABLE_FIRST_ENTRY + firstHeader.offset, assetTableBuffer);
    while (strcmp(curAsset->name, assetName) != 0) {
        ASSERT_MSG(strcmp(curAsset->name, "end_data") != 0, "Asset not found: %s", assetName);
        curAsset++;
    }
    *decompressedSize = curAsset->decompressedLength;
    ret = general_heap_malloc(curAsset->compressedLength);
    dma_copy((u8*) ASSET_TABLE_FIRST_ENTRY + curAsset->offset,
             (u8*) ASSET_TABLE_FIRST_ENTRY + curAsset->offset + curAsset->compressedLength, ret);
    heap_free(assetTableBuffer);
    return ret;
}

Referenced by btl_state_update_normal_start(), load_battle_hit_asset(), load_map_bg(), load_map_by_IDs(), load_map_hit_asset(), pause_partners_load_portrait(), state_init_title_screen(), state_step_end_battle(), and state_step_unpause().

◆ mdl_get_copied_gfx()

Gfx * mdl_get_copied_gfx ( s32 copyIndex )

Definition at line 4084 of file model.c.

                                       {
    ModelLocalVertexCopy* mlvc = (*gCurrentModelLocalVtxBuffers)[copyIndex];
    s32 selector = mlvc->selector;
    Gfx* gfxCopy = mlvc->gfxCopy[selector];
 
    mlvc->selector++;
    if (mlvc->selector > ARRAY_COUNT(mlvc->gfxCopy) - 1) {
        mlvc->selector = 0;
    }
 
    return gfxCopy;
}

Referenced by build_gfx_blue_stars(), build_gfx_green_stars(), build_gfx_pink_stars(), build_gfx_star(), build_gfx_yellow_stars(), unkAngleFunc002(), and unkAngleFunc003().

◆ mdl_get_copied_vertices()

void mdl_get_copied_vertices	(	s32	copyIndex,
		Vtx **	firstVertex,
		Vtx **	copiedVertices,
		s32 *	numCopied )

Definition at line 4075 of file model.c.

                                                                                                     {
    ModelLocalVertexCopy* mlvc = (*gCurrentModelLocalVtxBuffers)[copyIndex];
    s32 selector = mlvc->selector;
 
    *firstVertex = mlvc->minVertexAddr;
    *copiedVertices = mlvc->vtxCopy[selector];
    *numCopied = mlvc->numVertices;
}

Referenced by build_gfx_blue_stars(), build_gfx_green_stars(), build_gfx_pink_stars(), build_gfx_star(), build_gfx_yellow_stars(), unkAngleFunc002(), and unkAngleFunc003().

◆ mdl_draw_hidden_panel_surface()

void mdl_draw_hidden_panel_surface	(	Gfx **	arg0,
		u16	treeIndex )

Definition at line 4484 of file model.c.

                                                              {
    Model* model = get_model_from_list_index(get_model_list_index_from_tree_index(treeIndex));
    Model copied = *model;
    Gfx* oldGfxPos;
    s32 flag;
 
    if (*arg0 == gMainGfxPos) {
        flag = 1;
    }
 
    oldGfxPos = gMainGfxPos;
    gMainGfxPos = *arg0;
 
    copied.flags = MODEL_FLAG_HAS_LOCAL_VERTEX_COPY | MODEL_FLAG_VALID;
    appendGfx_model(&copied);
 
    *arg0 = gMainGfxPos;
 
    if (flag == 0) {
        gMainGfxPos = oldGfxPos;
    }
}

◆ is_point_visible()

b32 is_point_visible	(	f32	x,
		f32	y,
		f32	z,
		s32	depthQueryID,
		f32 *	screenX,
		f32 *	screenY )

Definition at line 4385 of file model.c.

                                                                                                       {
    Camera* camera = &gCameras[gCurrentCameraID];
    f32 outX;
    f32 outY;
    f32 outZ;
    f32 outW;
 
    s32 depthExponent;
    s32 depthMantissa;
    u32 shiftedMantissa, mantissaBias;
    u32 decodedDepth;
    s32 scaledDepth;
 
    // If an invalid depth query id was provided, return false.
    if (depthQueryID >= ARRAY_COUNT(DepthCopyBuffer)) {
        return FALSE;
    }
    // Transform the point into clip space.
    transform_point(camera->mtxPerspective, x, y, z, 1.0f, &outX, &outY, &outZ, &outW);
    if (outW == 0.0f) {
        *screenX = 0.0f;
        *screenY = 0.0f;
        return TRUE;
    }
    // Perform the perspective divide (divide xyz by w) to convert to normalized device coords.
    // Normalized device coords have a range of (-1, 1) on each axis.
    outW = 1.0f / outW;
    outX *= outW;
    outY *= -outW;
    outZ *= outW;
    // Perform the viewport transform for x and y (convert normalized device coords to viewport coords).
    // Viewport coords have a range of (0, Width) for x and (0, Height) for y.
    outX = (outX * camera->viewportW + camera->viewportW) * 0.5;
    outX += camera->viewportStartX;
    outY = (outY * camera->viewportH + camera->viewportH) * 0.5;
    outY += camera->viewportStartY;
    // Convert depth from (-1, 1) to (0, 1).
    outZ = (outZ + 1.0f) * 0.5;
    // Write out the calculated x and y values.
    *screenX = outX;
    *screenY = outY;
    // If a depth query wasn't requested, simply check if the point is within the view frustum.
    if (depthQueryID < 0) {
        return outZ > 0.0f;
    }
    if (outX >= 0.0f && outY >= 0.0f && outX < 320.0f && outY < 240.0f) {
        gDPPipeSync(gMainGfxPos++);
        // Load a 4x1 pixel tile of the depth buffer
        gDPLoadTextureTile(gMainGfxPos++, osVirtualToPhysical(&nuGfxZBuffer[(s32) outY * SCREEN_WIDTH]), G_IM_FMT_RGBA, G_IM_SIZ_16b, SCREEN_WIDTH, 1,
            (s32) outX, 0, (s32) outX + 3, 0,
            0,
            G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP,
            9, G_TX_NOMASK,
            G_TX_NOLOD, G_TX_NOLOD);
        gDPPipeSync(gMainGfxPos++);
        // Set the current color image to the buffer where copied depth values are stored.
        gDPSetColorImage(gMainGfxPos++, G_IM_FMT_RGBA, G_IM_SIZ_16b, SCREEN_WIDTH, DepthCopyBuffer);
        gDPPipeSync(gMainGfxPos++);
        // Set up 1 cycle mode and all other relevant othermode params.
        // One cycle mode must be used here because only one pixel is copied, and copy mode only supports multiples of 4 pixels.
        gDPSetCycleType(gMainGfxPos++, G_CYC_1CYCLE);
        gDPSetRenderMode(gMainGfxPos++, G_RM_OPA_SURF, G_RM_OPA_SURF2);
        gDPSetCombineMode(gMainGfxPos++, G_CC_DECALRGBA, G_CC_DECALRGBA);
        gDPSetTextureFilter(gMainGfxPos++, G_TF_POINT);
        gDPSetTexturePersp(gMainGfxPos++, G_TP_NONE);
        gSPTexture(gMainGfxPos++, 0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON);
        gDPSetTextureLUT(gMainGfxPos++, G_TT_NONE);
        gDPSetTextureDetail(gMainGfxPos++, G_TD_CLAMP);
        gDPSetTextureLOD(gMainGfxPos++, G_TL_TILE);
        // Adjust the scissor to only draw to the specified pixel.
        gDPSetScissor(gMainGfxPos++, G_SC_NON_INTERLACE, depthQueryID, 0, depthQueryID + 1, 1);
        // Draw a texrect to copy one pixel of the loaded depth tile to the output buffer.
        gSPTextureRectangle(gMainGfxPos++, depthQueryID << 2, 0 << 2, (depthQueryID + 1) << 2, 1 << 2, G_TX_RENDERTILE, (s32) outX << 5, 0, 1 << 10, 1 << 10);
        // Sync and swap the color image back to the current framebuffer.
        gDPPipeSync(gMainGfxPos++);
        gDPSetColorImage(gMainGfxPos++, G_IM_FMT_RGBA, G_IM_SIZ_16b, SCREEN_WIDTH, osVirtualToPhysical(nuGfxCfb_ptr));
        gDPPipeSync(gMainGfxPos++);
        // Reconfigure the frame's normal scissor.
        gDPSetScissor(gMainGfxPos++, G_SC_NON_INTERLACE, camera->viewportStartX, camera->viewportStartY, camera->viewportStartX + camera->viewportW, camera->viewportStartY + camera->viewportH);
 
        // The following code will use last frame's depth value, since the copy that was just written won't be executed until the current frame is drawn.
 
        // Extract the exponent and mantissa from the depth buffer value.
        depthExponent = DepthCopyBuffer[depthQueryID] >> DEPTH_EXPONENT_SHIFT;
        depthMantissa = (DepthCopyBuffer[depthQueryID] & (DEPTH_MANTISSA_MASK | DEPTH_DZ_MASK)) >> DEPTH_MANTISSA_SHIFT;
        // Convert the exponent and mantissa into a fixed-point value.
        shiftedMantissa = depthMantissa << DepthFloatLookupTable[depthExponent].shift;
        mantissaBias = DepthFloatLookupTable[depthExponent].bias;
        // Remove the 3 fractional bits of precision.
        decodedDepth = (shiftedMantissa + mantissaBias) >> 3;
        // Convert the calculated screen depth into viewport depth.
        scaledDepth = outZ * MAX_VIEWPORT_DEPTH;
        if (decodedDepth < scaledDepth) {
            return FALSE;
        }
    }
    return outZ > 0.0f;
}

◆ set_screen_overlay_center_worldpos()

void set_screen_overlay_center_worldpos	(	s32	idx,
		s32	posIdx,
		s32	x,
		s32	y,
		s32	z )

Definition at line 410 of file screen_overlays.c.

                                                                                                            {
    Camera* camera = &gCameras[gCurrentCameraID];
    f32 tx, ty, tz, tw;
 
    switch (layer) {
        case SCREEN_LAYER_FRONT:
        case SCREEN_LAYER_BACK:
            transform_point(camera->mtxPerspective, worldPosX, worldPosY, worldPosZ, 1.0f, &tx, &ty, &tz, &tw);
            tw = 1.0f / tw;
            tx *= tw;
            ty *= -tw;
            tz *= tw;
            tx = (((tx * camera->viewportW) + camera->viewportW) * 0.5) + camera->viewportStartX;
            ty = (((ty * camera->viewportH) + camera->viewportH) * 0.5) + camera->viewportStartY;
 
            switch (posIdx) {
                case 0:
                    ScreenOverlays[layer].screenPos[0][0] = tx;
                    ScreenOverlays[layer].screenPos[0][1] = ty;
                    break;
                case 1:
                    ScreenOverlays[layer].screenPos[1][0] = tx;
                    ScreenOverlays[layer].screenPos[1][1] = ty;
                    break;
            }
            break;
    }
}

◆ mdl_get_next_texture_address()

void * mdl_get_next_texture_address ( s32 size )

Definition at line 4507 of file model.c.

                                             {
    u32 offset = TextureHeapPos - TextureHeapBase + 0x3F;
 
    offset = (offset >> 6) << 6;
 
    if (size + offset > WORLD_TEXTURE_MEMORY_SIZE + BATTLE_TEXTURE_MEMORY_SIZE) {
        return NULL;
    } else {
        return TextureHeapBase + offset;
    }
}

Referenced by draw_box().

◆ cancel_current_message()

s32 cancel_current_message ( void )

Definition at line 312 of file msg_api.c.

                                 {
    cancel_message(gCurrentPrintContext);
    return 0;
}

Referenced by pre_battle().

◆ draw_msg()

void draw_msg	(	s32	msgID,
		s32	posX,
		s32	posY,
		s32	opacity,
		s32	palette,
		u8	style )

Definition at line 1987 of file msg.c.

                                                                                 {
    MessagePrintState stackPrinter;
    MessagePrintState* printer;
    u16 bufferPos;
    s8* mallocSpace;
    s32 charset;
    u16 flags;
    s32 width;
 
    flags = 0;
    bufferPos = 0;
    mallocSpace = NULL;
    charset = 0;
 
    if (msgID != 0) {
        if (style & DRAW_MSG_STYLE_MENU) {
            flags = 2;
            charset = 1;
        }
 
        if (opacity < 0xFF) {
            flags |= 1;
        }
 
        printer = &stackPrinter;
        initialize_printer(printer, 1, 0);
 
        if (msgID < 0) {
            printer->srcBuffer = (u8*)msgID;
        } else {
            mallocSpace = general_heap_malloc(0x400);
            dma_load_msg(msgID, mallocSpace);
            printer->srcBuffer = mallocSpace;
            get_msg_properties((s32) printer->srcBuffer, 0, &width, 0, 0, 0, 0, charset);
            printer->msgWidth = width;
        }
 
        if (palette >= 0) {
            printer->printBuffer[bufferPos++] = MSG_CHAR_PRINT_FUNCTION;
            printer->printBuffer[bufferPos++] = MSG_PRINT_FUNC_COLOR;
            printer->printBuffer[bufferPos++] = palette;
            printer->printBufferPos += 3;
        }
 
        if (style & DRAW_MSG_STYLE_WAVY) {
            printer->printBuffer[bufferPos++] = MSG_CHAR_PRINT_FUNCTION;
            printer->printBuffer[bufferPos++] = MSG_PRINT_FUNC_START_FX;
            printer->printBuffer[bufferPos++] = MSG_FX_GLOBAL_WAVE;
            printer->printBufferPos += 3;
        }
 
        if (style & DRAW_MSG_STYLE_RAINBOW) {
            printer->printBuffer[bufferPos++] = MSG_CHAR_PRINT_FUNCTION;
            printer->printBuffer[bufferPos++] = MSG_PRINT_FUNC_START_FX;
            printer->printBuffer[bufferPos++] = MSG_FX_GLOBAL_RAINBOW;
            printer->printBufferPos += 3;
        }
 
        if (style & DRAW_MSG_STYLE_DROP_SHADOW) {
            printer->printBuffer[bufferPos++] = MSG_CHAR_PRINT_FUNCTION;
            printer->printBuffer[bufferPos++] = MSG_PRINT_FUNC_START_FX;
            printer->printBuffer[bufferPos++] = MSG_FX_DROP_SHADOW;
            printer->printBufferPos += 3;
        }
 
        msg_copy_to_print_buffer(printer, 10000, 1);
        appendGfx_message(printer, (s16)posX, (s16)posY, 0, 0, flags, opacity & 0xFF);
 
        if (mallocSpace != NULL) {
            general_heap_free(mallocSpace);
        }
    }
}

◆ mdl_get_shroud_tint_params()

void mdl_get_shroud_tint_params	(	u8 *	r,
		u8 *	g,
		u8 *	b,
		u8 *	a )

Definition at line 3912 of file model.c.

                                                            {
    *r = ShroudTintR;
    *g = ShroudTintG;
    *b = ShroudTintB;
    *a = ShroudTintAmt;
}

◆ entity_base_block_idle()

s32 entity_base_block_idle ( Entity * entity )

Definition at line 195 of file Block.c.

                                           {
    BlockData* data = entity->dataBuf.block;
    s32 ret = 0;
 
    if (is_block_on_ground(entity) != 0) {
        if (entity->flags & ENTITY_FLAG_200000) {
            ret = 1;
            entity_base_block_update_slow_sinking(entity);
            if (data->item != -1) {
                ItemEntity* itemEntity = get_item_entity(data->item);
                itemEntity->pos.y = entity->pos.y + 4.0f;
            }
        }
    }
 
    return ret;
}

Referenced by entity_block_hit_animate_scale(), entity_BrickBlock_idle(), entity_HeartBlock_idle(), entity_ItemBlock_idle(), entity_MulticoinBlock_idle(), entity_SaveBlock_idle(), and entity_upgrade_block_idle().

◆ add_star_power()

void add_star_power ( s32 amt )

Definition at line 2145 of file inventory.c.

                             {
    PlayerData* playerData = &gPlayerData;
    StatusBar* statusBar = &gStatusBar;
    s32 maxPower;
    s32 newPower;
 
    statusBar->shimmerState = STATUS_SHIMMER_BEGIN;
    statusBar->shimmerTime = 60;
 
    if (playerData->starPower < 0) {
        statusBar->shimmerLimit = (playerData->starPower + 31) / SP_PER_SEG;
    } else {
        statusBar->shimmerLimit = playerData->starPower / SP_PER_SEG;
    }
 
    playerData->starPower += amt;
 
    maxPower = playerData->maxStarPower * SP_PER_BAR;
    if (playerData->starPower > maxPower) {
        playerData->starPower = maxPower;
    }
 
    gStatusBar.displayStarPower = gPlayerData.starPower;
}

◆ entity_can_collide_with_jumping_player()

s32 entity_can_collide_with_jumping_player ( Entity * entity )

Definition at line 11 of file Shadow.c.

                                                           {
    if ((entity->collisionFlags & ENTITY_COLLISION_PLAYER_TOUCH_CEILING)
        && (gPlayerStatus.flags & PS_FLAG_JUMPING)
    ) {
        return TRUE;
    }
    return FALSE;
}

Referenced by entity_HeartBlockContent_anim_idle().

◆ entity_base_block_init()

void entity_base_block_init ( Entity * entity )

Definition at line 213 of file Block.c.

                                            {
    BlockData* data = entity->dataBuf.block;
 
    data->item = -1;
    data->initialY = entity->pos.y;
    data->sinkingTimer = -1;
    entity->flags &= ~ENTITY_FLAG_200000;
}

Referenced by entity_HeartBlock_create_child_entity(), entity_init_Hammer1Block_normal(), entity_ItemBlock_init(), entity_ItemlessBlock_init(), entity_MulticoinBlock_init(), entity_SaveBlock_init(), and entity_upgrade_block_init().

◆ entity_start_script()

s32 entity_start_script ( Entity * entity )

Definition at line 560 of file entity.c.

                                        {
    if (entity->boundScriptBytecode != NULL) {
        entity->flags |= ENTITY_FLAG_BOUND_SCRIPT_DIRTY;
        return 1;
    }
    return 0;
}

Referenced by action_update_use_tweester(), entity_ArrowSign_handle_collision(), entity_base_switch_start_bound_script(), entity_block_handle_collision(), entity_BlueWarpPipe_start_bound_script(), Entity_BoardedFloor_idle(), entity_BombableRock_idle(), entity_Chest_start_bound_script(), entity_GreenStompSwitch_retract(), entity_Padlock_idle(), entity_ScriptSpring_idle(), entity_Signpost_idle(), entity_SimpleSpring_idle(), entity_StarBoxLauncher_start_script(), entity_TriggerBlock_start_bound_script_2(), and entity_WoodenCrate_idle().

◆ init_item_entity_list()

void init_item_entity_list ( void )

Definition at line 274 of file item_entity.c.

                                 {
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentItemEntities = WorldItemEntities;
    } else {
        gCurrentItemEntities = BattleItemEntities;
    }
 
    isPickingUpItem = FALSE;
#if !VERSION_JP
    D_801565A8 = FALSE;
#endif
    ItemEntitiesCreated = 0;
    ItemEntityAlternatingSpawn = 0;
}

Referenced by state_step_end_battle(), and state_step_unpause().

◆ init_script_list()

void init_script_list ( void )

Definition at line 182 of file script_list.c.

                            {
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentScriptListPtr = &gWorldScriptList;
        gMapVars = gWorldMapVars;
        gMapFlags = gWorldMapFlags;
    } else {
        gCurrentScriptListPtr = &gBattleScriptList;
        gMapVars = gBattleMapVars;
        gMapFlags = gBattleMapFlags;
    }
 
    gNumScripts = 0;
    IsUpdatingScripts = FALSE;
 
    init_virtual_entity_list();
    init_model_animators();
}

Referenced by state_step_end_battle(), and state_step_unpause().

◆ init_entity_data()

void init_entity_data ( void )

Definition at line 840 of file entity.c.

                            {
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gEntityHeapBottom = WORLD_ENTITY_HEAP_BOTTOM;
        gEntityHeapBase = WORLD_ENTITY_HEAP_BASE;
        reload_world_entity_data();
    } else {
        s32 i;
 
        for (i = 0; i < ARRAY_COUNT(bEntityBlueprint); i++) {
            bEntityBlueprint[i] = 0;
        }
        gEntityHeapBottom = (s32) BattleEntityHeapBottom;
        gEntityHeapBase = gEntityHeapBottom + 0x3000;
    }
    gCurrentEntityListPtr = get_entity_list();
    gCurrentShadowListPtr = get_shadow_list();
    entity_numEntities = 0;
    entity_numShadows = 0;
}

Referenced by state_step_end_battle(), and state_step_unpause().

◆ init_trigger_list()

void init_trigger_list ( void )

Definition at line 45 of file trigger.c.

                             {
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentTriggerListPtr = &wTriggerList;
    } else {
        gCurrentTriggerListPtr = &bTriggerList;
    }
 
    gTriggerCount = 0;
}

Referenced by state_step_end_battle(), and state_step_unpause().

◆ partner_init_after_battle()

void partner_init_after_battle ( s32 arg0 )

Definition at line 926 of file partners.c.

                                              {
    PlayerStatus* playerStatus = &gPlayerStatus;
    PartnerStatus* partnerStatus = &gPartnerStatus;
 
    if (wCurrentPartnerId != partnerID) {
        D_8010CFE0 = 1;
        NextPartnerID = partnerID;
        partnerStatus->partnerActionState = 0;
        partnerStatus->shouldResumeAbility = FALSE;
 
        if (wCurrentPartnerId != PARTNER_NONE && partnerID != PARTNER_NONE) {
            NextPartnerCommand = PARTNER_CMD_INSTA_SWITCH;
        } else if (partnerID == PARTNER_NONE) {
            NextPartnerCommand = PARTNER_CMD_PUT_AWAY;
        } else {
            NextPartnerCommand = PARTNER_CMD_TAKE_OUT;
            wSavedPartnerPosX = playerStatus->pos.x;
            wSavedPartnerPosY = playerStatus->pos.y;
            wSavedPartnerPosZ = playerStatus->pos.z;
        }
    }
}

Referenced by state_step_end_battle().

◆ load_map_script_lib()

void load_map_script_lib ( void )

Definition at line 49 of file world.c.

                               {
    DMA_COPY_SEGMENT(world_script_api);
}

Referenced by load_map_by_IDs(), state_step_end_battle(), and state_step_unpause().

◆ remove_item_entity_by_index()

void remove_item_entity_by_index ( s32 index )

Definition at line 1287 of file item_entity.c.

                                            {
    ItemEntity* item = gCurrentItemEntities[index];
 
    switch (item->spawnType) {
        case ITEM_SPAWN_MODE_KEY:
        case ITEM_SPAWN_MODE_TOSS_SPAWN_ALWAYS:
        case ITEM_SPAWN_MODE_FALL_SPAWN_ALWAYS:
        case ITEM_SPAWN_MODE_FIXED_SPAWN_ALWAYS:
        case ITEM_SPAWN_MODE_ITEM_BLOCK_SPAWN_ALWAYS:
        case ITEM_SPAWN_AT_PLAYER:
            delete_shadow(item->shadowIndex);
            break;
    }
 
    heap_free(gCurrentItemEntities[index]);
    gCurrentItemEntities[index] = NULL;
    isPickingUpItem = FALSE;
}

Referenced by entity_GiantChest_await_got_item().

◆ set_entity_commandlist()

void set_entity_commandlist	(	Entity *	entity,
		s32 *	entityScript )

Definition at line 235 of file entity.c.

                                                               {
    entity->scriptReadPos = entityScript;
    entity->scriptDelay = 1;
    entity->savedReadPos[0] = entity->scriptReadPos;
}

Referenced by entity_block_handle_collision(), entity_Chest_check_opened(), entity_ItemBlock_check_if_inactive(), entity_MulticoinBlock_spawn_coin(), and entity_SaveBlock_wait_for_close_choice().

◆ is_player_dismounted()

s32 is_player_dismounted ( void )

Definition at line 827 of file 77480.c.

                               {
    if (gPartnerStatus.partnerActionState == PARTNER_ACTION_USE &&
        (gPartnerStatus.actingPartner == PARTNER_WATT
        || gPartnerStatus.actingPartner == PARTNER_BOW
        || gPartnerStatus.actingPartner == PARTNER_SUSHIE
        || gPartnerStatus.actingPartner == PARTNER_PARAKARRY
        || gPartnerStatus.actingPartner == PARTNER_LAKILESTER)) {
        return FALSE;
    }
    return TRUE;
}

Referenced by get_overriding_player_anim(), and update_item_entity_pickup().

◆ func_800EF300()

void func_800EF300 ( void )

Definition at line 2382 of file partners.c.

                         {
    wPartnerFollowState = 40;
}

Referenced by action_update_use_spinning_flower(), entity_CymbalPlant_idle(), and func_802BC050_E2E980().

◆ func_800EF314()

void func_800EF314 ( void )

Definition at line 2386 of file partners.c.

                         {
    wPartnerFollowState = 50;
}

◆ func_800EF43C()

void func_800EF43C ( void )

Definition at line 2430 of file partners.c.

                         {
    wPartnerFollowState = 0;
    D_8010CFCA = 0;
    D_8010CFCE = 0;
}

◆ func_800EF3E4()

void func_800EF3E4 ( void )

Definition at line 2418 of file partners.c.

                         {
    wPartnerFollowState = 15;
    D_8010CFCA = 0;
    wPartnerMoveTime = 10;
    D_8010CFCE = 0;
}

Referenced by entity_Chest_idle().

◆ enable_player_shadow()

void enable_player_shadow ( void )

Definition at line 964 of file 77480.c.

                                {
    get_shadow_by_index(gPlayerStatus.shadowID)->flags &= ~ENTITY_FLAG_HIDDEN;
}

Referenced by func_802BC3A0_E2ECD0().

◆ get_msg_lines()

s32 get_msg_lines ( s32 messageID )

Definition at line 1979 of file msg.c.

                             {
    s32 numLines;
 
    get_msg_properties(msgID, NULL, NULL, NULL, &numLines, NULL, NULL, 0);
    return numLines;
}

Referenced by btl_menu_moves_show_error(), btl_message_popup_draw_content(), btl_show_message_popup(), btl_submenu_moves_update(), draw_content_pickup_item_header(), draw_merlee_message(), draw_merlee_message_string(), func_800F4C1C(), func_801363A0(), and popup_menu_update().

◆ set_window_properties()

void set_window_properties	(	s32	panelID,
		s32	posX,
		s32	posY,
		s32	width,
		s32	height,
		u8	priority,
		void *	drawContents,
		void *	drawContentsArg,
		s8	parent )

Definition at line 373 of file windows.c.

                                                                                                                                                          {
    Window* window = &gWindows[windowID];
    u8 priorityCopy = priority;
 
    window->flags = WINDOW_FLAG_INITIALIZED | WINDOW_FLAG_HIDDEN;
    window->pos.x = posX;
    window->pos.y = posY;
    window->width = width;
    window->fpUpdate.i = 0;
    window->parent = parent;
    window->height = height;
    window->fpDrawContents = fpDrawContents;
    window->drawContentsArg0 = drawContentsArg0;
    if (parent >= 0) {
        gWindows[parent].flags |= WINDOW_FLAG_HAS_CHILDREN;
    }
    update_window_hierarchy(windowID, priorityCopy);
    window->originalPriority = priority;
}

Referenced by btl_show_message_popup(), btl_state_update_celebration(), btl_submenu_moves_update(), btl_update_strats_menu(), draw_merlee_message(), func_801363A0(), popup_menu_update(), setup_pause_menu_tab(), and show_coin_counter().

◆ set_window_update()

void set_window_update	(	s32	panelID,
		s32	func )

Definition at line 434 of file windows.c.

                                               {
    if (gWindows[windowID].flags & WINDOW_FLAG_INITIALIZED) {
        if (func == gWindows[windowID].fpUpdate.i) {
            gWindows[windowID].flags &= ~WINDOW_FLAG_FPUPDATE_CHANGED;
        } else {
            gWindows[windowID].flags |= WINDOW_FLAG_FPUPDATE_CHANGED | WINDOW_FLAG_INITIAL_ANIMATION;
            gWindows[windowID].fpPending.i = func;
        }
    }
}

Referenced by btl_show_message_popup(), btl_state_update_celebration(), btl_state_update_partner_menu(), btl_state_update_player_menu(), btl_submenu_moves_update(), btl_update_message_popup(), btl_update_strats_menu(), draw_merlee_message(), draw_shop_items(), filemenu_choose_name_handle_input(), filemenu_cleanup(), filemenu_info_handle_input(), filemenu_main_handle_input(), filemenu_main_init(), filemenu_update_change_layout(), filemenu_yesno_handle_input(), func_800F16CC(), func_802A27E4(), func_802A2910(), func_802A2AB8(), func_802A2C58(), func_802A472C(), func_802A47E0(), func_802A48FC(), func_802A4A10(), hide_popup_menu(), pause_cleanup(), pause_init(), pause_partners_handle_input(), pause_partners_init(), pause_tabs_update(), popup_menu_update(), setup_pause_menu_tab(), show_coin_counter(), update_coin_counter(), update_item_entity_pickup(), and update_merlee_message().

◆ set_windows_visible()

void set_windows_visible ( s32 groupIdx )

Definition at line 445 of file windows.c.

                                       {
    u8 min = gWindowGroups[groupIdx].min;
    u8 max = gWindowGroups[groupIdx].max;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gWindows); i++) {
        if (gWindows[i].flags & WINDOW_FLAG_INITIALIZED) {
            if (i < min || i > max) {
                gWindows[i].flags |= WINDOW_FLAG_DISABLED;
            } else {
                gWindows[i].flags &= ~WINDOW_FLAG_DISABLED;
            }
        }
    }
}

Referenced by btl_state_update_end_battle(), btl_state_update_end_demo_battle(), initialize_battle(), state_init_pause(), state_step_exit_file_select(), state_step_file_select(), and state_step_unpause().

◆ partner_disable_input()

void partner_disable_input ( void )

Definition at line 2489 of file partners.c.

                                 {
    PartnerStatus* partnerStatus = &gPartnerStatus;
 
    partnerStatus->inputDisabledCount++;
}

Referenced by check_input_open_menus(), SentinelAI_Descend(), start_battle(), update_encounters_neutral(), and update_item_entity_pickup().

◆ partner_set_goal_pos()

void partner_set_goal_pos	(	s32	x,
		s32	z )

Definition at line 2409 of file partners.c.

                                        {
    wPartnerMoveGoalX = x;
    wPartnerMoveGoalZ = z;
}

Referenced by func_800EF414().

◆ close_message()

void close_message ( MessagePrintState * msgPrintState )

Definition at line 1568 of file msg.c.

                                                     {
    msgPrintState->stateFlags &= ~MSG_STATE_FLAG_40;
}

Referenced by _show_message(), and entity_SaveBlock_wait_for_close_choice().

◆ show_foreground_models_unchecked()

void show_foreground_models_unchecked ( void )

Definition at line 2978 of file 190B20.c.

                                            {
    Stage* stage = gBattleStatus.curStage;
 
    if (stage != NULL && stage->foregroundModelList != NULL) {
        s32* idList = stage->foregroundModelList;
        while (*idList != STAGE_MODEL_LIST_END) {
            s32 id = *idList++;
            if (id >= 0) {
                Model* model = get_model_from_list_index(get_model_list_index_from_tree_index(id));
                model->flags &= ~MODEL_FLAG_HIDDEN;
            }
        }
    }
}

Referenced by tattle_cam_post_render().

◆ hide_foreground_models_unchecked()

void hide_foreground_models_unchecked ( void )

Definition at line 2963 of file 190B20.c.

                                            {
    Stage* stage = gBattleStatus.curStage;
 
    if (stage != NULL && stage->foregroundModelList != NULL) {
        s32* idList = stage->foregroundModelList;
        while (*idList != STAGE_MODEL_LIST_END) {
            s32 id = *idList++;
            if (id >= 0) {
                Model* model = get_model_from_list_index(get_model_list_index_from_tree_index(id));
                model->flags |= MODEL_FLAG_HIDDEN;
            }
        }
    }
}

Referenced by tattle_cam_pre_render().

◆ show_foreground_models()

void show_foreground_models ( void )

Definition at line 3011 of file 190B20.c.

                                  {
    Stage* stage = gBattleStatus.curStage;
 
    if (stage != NULL && stage->foregroundModelList != NULL) {
        s32* idList = stage->foregroundModelList;
        while (*idList != STAGE_MODEL_LIST_END) {
            s32 id = *idList++;
            if (id < 0) {
                break;
            } else {
                Model* model = get_model_from_list_index(get_model_list_index_from_tree_index(id));
                model->flags &= ~MODEL_FLAG_HIDDEN;
            }
        }
    }
}

◆ hide_foreground_models()

void hide_foreground_models ( void )

Definition at line 2993 of file 190B20.c.

                                  {
    Stage* stage = gBattleStatus.curStage;
 
    if (stage != NULL && stage->foregroundModelList != NULL) {
        s32* idList = stage->foregroundModelList;
        while (*idList != STAGE_MODEL_LIST_END) {
            s32 id = *idList++;
            if (id < 0) {
                break;
            } else {
                Model* model = get_model_from_list_index(get_model_list_index_from_tree_index(id));
                model->flags |= MODEL_FLAG_HIDDEN;
            }
 
        }
    }
}

◆ btl_set_state()

void btl_set_state ( s32 battleState )

Definition at line 166 of file btl_states_actions.c.

                                    {
    s32 flags = gBattleStatus.flags2;
    gBattleState = battleState;
    gBattleSubState = BTL_SUBSTATE_INIT;
 
    flags &= BS_FLAGS2_PEACH_BATTLE;
    if (flags) {
        switch (battleState) {
            case BATTLE_STATE_PARTNER_MENU:
                battleState = BATTLE_STATE_TWINK_MENU;
                break;
            case BATTLE_STATE_PLAYER_MENU:
                battleState = BATTLE_STATE_PEACH_MENU;
                break;
            case BATTLE_STATE_BEGIN_PLAYER_TURN:
                battleState = BATTLE_STATE_BEGIN_PARTNER_TURN;
                break;
            case BATTLE_STATE_BEGIN_PARTNER_TURN:
                battleState = BATTLE_STATE_BEGIN_PLAYER_TURN;
                break;
        }
        gBattleState = battleState;
    }
}

◆ draw_entity_model_A()

void draw_entity_model_A	(	s32	modelIdx,
		Mtx *	transformMtx )

Definition at line 405 of file entity_model.c.

                                                          {
    EntityModel* model;
    RenderTask rt;
    RenderTask* rtPtr = &rt;
    Camera* camera = &gCameras[gCurrentCamID];
    Matrix4f mtx;
    f32 x, y, z, w;
    f32 inX, inY, inZ;
 
    if ((gGameStatusPtr->context == CONTEXT_WORLD) || (modelIdx & BATTLE_ENTITY_ID_BIT)) {
        modelIdx &= ~BATTLE_ENTITY_ID_BIT;
        model = (*gCurrentEntityModelList)[modelIdx];
 
        if (model != NULL) {
            if (model->flags != 0) {
                if (!(model->flags & ENTITY_MODEL_FLAG_100)) {
                    if (!(model->flags & ENTITY_MODEL_FLAG_HIDDEN)) {
                        if (!(model->flags & ENTITY_MODEL_FLAG_40) && (model->flags & (1 << gCurrentCamID))) {
                            model->transform = *transformMtx;
                            model->vertexArray = NULL;
                            guMtxL2F(mtx, transformMtx);
                            inX = mtx[3][0];
                            inY = mtx[3][1];
                            inZ = mtx[3][2];
                            transform_point(camera->mtxPerspective, inX, inY, inZ, 1.0f, &x, &y, &z, &w);
                            rtPtr->renderMode = model->renderMode;
                            rtPtr->appendGfxArg = model;
                            rtPtr->appendGfx = (void(*)(void*))appendGfx_entity_model;
                            rtPtr->dist = ((u32)(model->flags & 0xF000) >> 8) + inZ;
                            queue_render_task(rtPtr);
                        }
                    }
                }
            }
        }
    }
}

Referenced by btl_bonk_render(), render_entities(), render_shadows(), and virtual_entity_list_render_world().

◆ draw_entity_model_B()

void draw_entity_model_B	(	s32	modelIdx,
		Mtx *	transformMtx,
		s32	vertexSegment,
		Vec3s *	vertexArray )

Definition at line 443 of file entity_model.c.

                                                                                                 {
    EntityModel* model;
    RenderTask rt;
    RenderTask* rtPtr = &rt;
    Camera* camera = &gCameras[gCurrentCamID];
    Matrix4f mtx;
    f32 x, y, z, w;
    f32 inX, inY, inZ;
 
    if ((gGameStatusPtr->context == CONTEXT_WORLD) || (modelIdx & BATTLE_ENTITY_ID_BIT)) {
        modelIdx &= ~BATTLE_ENTITY_ID_BIT;
        model = (*gCurrentEntityModelList)[modelIdx];
 
        if (model != NULL) {
            if (model->flags != 0) {
                if (!(model->flags & ENTITY_MODEL_FLAG_100)) {
                    if (!(model->flags & ENTITY_MODEL_FLAG_HIDDEN)) {
                        if (model->flags & (1 << gCurrentCamID)) {
                            model->transform = *transformMtx;
                            D_80154374 = vertexSegment;
                            model->vertexArray = vertexArray;
                            guMtxL2F(mtx, transformMtx);
                            inX = mtx[3][0];
                            inY = mtx[3][1];
                            inZ = mtx[3][2];
                            transform_point(camera->mtxPerspective, inX, inY, inZ, 1.0f, &x, &y, &z, &w);
                            rtPtr->renderMode = model->renderMode;
                            rtPtr->appendGfxArg = model;
                            rtPtr->appendGfx = (void(*)(void*))appendGfx_entity_model;
                            rtPtr->dist = ((u32)(model->flags & 0xF000) >> 8) + inZ;
                            queue_render_task(rtPtr);
                        }
                    }
                }
            }
        }
    }
}

Referenced by render_entities(), and render_shadows().

◆ draw_entity_model_C()

void draw_entity_model_C	(	s32	modelIdx,
		Mtx *	transformMtx )

Definition at line 482 of file entity_model.c.

                                                          {
    EntityModel* model;
    RenderTask rt;
    RenderTask* rtPtr = &rt;
 
    if ((gGameStatusPtr->context == CONTEXT_WORLD) || (modelIdx & BATTLE_ENTITY_ID_BIT)) {
        modelIdx &= ~BATTLE_ENTITY_ID_BIT;
        model = (*gCurrentEntityModelList)[modelIdx];
 
        if (model != NULL) {
            if (model->flags != 0) {
                if (!(model->flags & ENTITY_MODEL_FLAG_100)) {
                    if (!(model->flags & ENTITY_MODEL_FLAG_HIDDEN)) {
                        if (!(model->flags & ENTITY_MODEL_FLAG_40) && (model->flags & (1 << gCurrentCamID))) {
                            model->flags |= ENTITY_MODEL_FLAG_REFLECT;
                            model->transform = *transformMtx;
                            model->vertexArray = NULL;
                            rtPtr->renderMode = model->renderMode;
                            rtPtr->appendGfxArg = model;
                            rtPtr->appendGfx = (void(*)(void*))appendGfx_entity_model;
                            rtPtr->dist = (u32)(model->flags & 0xF000) >> 8;
                            queue_render_task(rtPtr);
                        }
                    }
                }
            }
        }
    }
}

◆ draw_entity_model_D()

void draw_entity_model_D	(	s32	modelIdx,
		Mtx *	transformMtx,
		s32	arg2,
		Vec3s *	vertexArray )

Definition at line 512 of file entity_model.c.

                                                                                        {
    EntityModel* model;
    RenderTask rt;
    RenderTask* rtPtr = &rt;
 
    if ((gGameStatusPtr->context == CONTEXT_WORLD) || (modelIdx & BATTLE_ENTITY_ID_BIT)) {
        modelIdx &= ~BATTLE_ENTITY_ID_BIT;
        model = (*gCurrentEntityModelList)[modelIdx];
 
        if (model != NULL) {
            if (model->flags != 0) {
                if (!(model->flags & ENTITY_MODEL_FLAG_100)) {
                    if (!(model->flags & ENTITY_MODEL_FLAG_HIDDEN)) {
                        if (model->flags & (1 << gCurrentCamID)) {
                            model->flags |= ENTITY_MODEL_FLAG_REFLECT;
                            model->transform = *transformMtx;
                            D_80154374 = arg2;
                            model->vertexArray = vertexArray;
                            rtPtr->renderMode = model->renderMode;
                            rtPtr->appendGfxArg = model;
                            rtPtr->appendGfx = (void(*)(void*))appendGfx_entity_model;
                            rtPtr->dist = (u32)(model->flags & 0xF000) >> 8;
                            queue_render_task(rtPtr);
                        }
                    }
                }
            }
        }
    }
}

◆ draw_entity_model_E()

void draw_entity_model_E	(	s32	modelIdx,
		Mtx *	transformMtx )

Definition at line 543 of file entity_model.c.

                                                          {
    EntityModel* model = (*gCurrentEntityModelList)[modelIdx & ~BATTLE_ENTITY_ID_BIT];
    Matrix4f mtx;
    Matrix4f mtx2;
    ImgFXTexture ifxImg;
    Matrix4f imgfxMtx;
 
    if (model == NULL) {
        return;
    }
    if (model->flags == 0) {
        return;
    }
    if (model->flags & ENTITY_MODEL_FLAG_100) {
        return;
    }
    if (model->flags & ENTITY_MODEL_FLAG_HIDDEN) {
        return;
    }
    if (model->flags & ENTITY_MODEL_FLAG_40) {
        return;
    }
    if (!(model->flags & ENTITY_MODEL_FLAG_CAM3)) {
        return;
    }
 
    model->transform = *transformMtx;
    model->vertexArray = NULL;
    gDisplayContext->matrixStack[gMatrixListPos] = model->transform;
    gSPMatrix(gMainGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++], G_MTX_PUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
    if (!(model->flags & ENTITY_MODEL_FLAG_USE_IMAGE)) {
        switch (entity_fog_enabled && !(model->flags & ENTITY_MODEL_FLAG_FOG_DISABLED)) {
            case FALSE:
                switch (model->renderMode) {
                    case RENDER_MODE_SURFACE_OPA:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM1_SURFACE_OPA);
                        break;
                    case RENDER_MODE_DECAL_OPA:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM1_DECAL_OPA);
                        break;
                    case RENDER_MODE_INTERSECTING_OPA:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM1_INTERSECTING_OPA);
                        break;
                    case RENDER_MODE_ALPHATEST:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM1_ALPHATEST);
                        break;
                    case RENDER_MODE_SURFACE_XLU_LAYER1:
                    case RENDER_MODE_SURFACE_XLU_LAYER2:
                    case RENDER_MODE_SURFACE_XLU_LAYER3:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM1_SURFACE_XLU);
                        break;
                    case RENDER_MODE_SURFACE_XLU_NO_AA:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM1_SURFACE_XLU_NO_AA);
                        break;
                    case RENDER_MODE_DECAL_XLU:
                    case RENDER_MODE_DECAL_XLU_AHEAD:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM1_DECAL_XLU);
                        break;
                    case RENDER_MODE_DECAL_XLU_NO_AA:
                    case RENDER_MODE_SHADOW:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM1_DECAL_XLU_NO_AA);
                        break;
                    case RENDER_MODE_INTERSECTING_XLU:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM1_INTERSECTING_XLU);
                        break;
                    case RENDER_MODE_PASS_THROUGH:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM1_PASS_THROUGH);
                        break;
                    case RENDER_MODE_ALPHATEST_ONESIDED:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM1_ALPHATEST_ONESIDED);
                        break;
                    case RENDER_MODE_SURFACE_OPA_NO_ZB:
                    case RENDER_MODE_SURFACE_OPA_NO_ZB_BEHIND:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM1_SURFACE_OPA_NO_ZB);
                        break;
                    case RENDER_MODE_ALPHATEST_NO_ZB:
                    case RENDER_MODE_ALPHATEST_NO_ZB_BEHIND:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM1_ALPHATEST_NO_ZB);
                        break;
                    case RENDER_MODE_SURFACE_XLU_NO_ZB:
                    case RENDER_MODE_SURFACE_XLU_NO_ZB_BEHIND:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM1_SURFACE_XLU_NO_ZB);
                        break;
                    case RENDER_MODE_CLOUD_NO_ZCMP:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM1_CLOUD_NO_ZCMP);
                        break;
                }
                break;
            case TRUE:
                switch (model->renderMode) {
                    case RENDER_MODE_SURFACE_OPA:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM3_SURFACE_OPA);
                        break;
                    case RENDER_MODE_DECAL_OPA:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM3_DECAL_OPA);
                        break;
                    case RENDER_MODE_INTERSECTING_OPA:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM3_INTERSECTING_OPA);
                        break;
                    case RENDER_MODE_ALPHATEST:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM3_ALPHATEST);
                        break;
                    case RENDER_MODE_SURFACE_XLU_LAYER1:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM3_SURFACE_XLU);
                        break;
                    case RENDER_MODE_DECAL_XLU:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM3_DECAL_XLU);
                        break;
                    case RENDER_MODE_INTERSECTING_XLU:
                        gSPDisplayList(gMainGfxPos++, Gfx_RM3_INTERSECTING_XLU);
                        break;
                }
                gDPSetFogColor(gMainGfxPos++, entity_fog_red, entity_fog_green, entity_fog_blue, entity_fog_alpha);
                gSPFogPosition(gMainGfxPos++, entity_fog_dist_min, entity_fog_dist_max);
                break;
        }
        gSPClearGeometryMode(gMainGfxPos++, G_LIGHTING);
        if (!entity_fog_enabled || (model->flags & ENTITY_MODEL_FLAG_FOG_DISABLED)) {
            gDPSetCombineMode(gMainGfxPos++, G_CC_MODULATEIA, G_CC_MODULATEIA);
        } else {
            gDPSetCombineMode(gMainGfxPos++, PM_CC_42, PM_CC2_MULTIPLY_SHADE);
        }
        if (model->vertexArray != NULL) {
            gSPSegment(gMainGfxPos++, D_80154374, VIRTUAL_TO_PHYSICAL(model->vertexArray));
        }
        gSPDisplayList(gMainGfxPos++, model->gfx.displayList);
        gSPPopMatrix(gMainGfxPos++, G_MTX_MODELVIEW);
        gDPPipeSync(gMainGfxPos++);
        if (!(model->flags & ENTITY_MODEL_FLAG_REFLECT)) {
            return;
        }
 
        guMtxL2F(mtx, &model->transform);
        make_entity_model_mtx_flipZ(mtx2);
        guMtxCatF(mtx, mtx2, mtx);
        guMtxF2L(mtx, &model->transform);
        gDisplayContext->matrixStack[gMatrixListPos] = model->transform;
        gSPMatrix(gMainGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++], G_MTX_PUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
        gSPDisplayList(gMainGfxPos++, model->gfx.displayList);
    } else {
        SpriteRasterInfo* imageData;
 
        gDPPipeSync(gMainGfxPos++);
        gSPClearGeometryMode(gMainGfxPos++, G_ZBUFFER | G_SHADE | G_CULL_BOTH | G_FOG | G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR | G_LOD | G_SHADING_SMOOTH);
        gSPSetGeometryMode(gMainGfxPos++, G_ZBUFFER | G_SHADE | G_LIGHTING | G_SHADING_SMOOTH);
        gSPSetLights1(gMainGfxPos++, D_8014C268);
        gSPTexture(gMainGfxPos++, -1, -1, 0, G_TX_RENDERTILE, G_ON);
        gDPSetAlphaCompare(gMainGfxPos++, G_AC_NONE);
        gSPSetOtherMode(gMainGfxPos++, G_SETOTHERMODE_H, G_MDSFT_ALPHADITHER, 18, G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_NONE | G_TL_TILE | G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE);
 
        imageData = model->gfx.imageData;
        ifxImg.raster = imageData->raster;
        ifxImg.palette = imageData->defaultPal;
        ifxImg.width = imageData->width;
        ifxImg.height = imageData->height;
        ifxImg.xOffset = -imageData->width / 2;
        ifxImg.yOffset = imageData->height / 2;
        ifxImg.alpha = 255;
        guMtxL2F(imgfxMtx, &model->transform);
        imgfx_appendGfx_component(0, &ifxImg, 0, imgfxMtx);
    }
 
    gSPPopMatrix(gMainGfxPos++, G_MTX_MODELVIEW);
    gDPPipeSync(gMainGfxPos++);
}

Referenced by virtual_entity_list_render_UI().

◆ free_entity_model_by_index()

void free_entity_model_by_index ( s32 idx )

Definition at line 727 of file entity_model.c.

                                         {
    s32 index = idx & ~BATTLE_ENTITY_ID_BIT;
    EntityModel* entityModel = (*gCurrentEntityModelList)[index];
 
    if (entityModel != NULL && entityModel->flags) {
        if (entityModel->flags & ENTITY_MODEL_FLAG_USE_IMAGE) {
            heap_free(entityModel->gfx.imageData);
        }
        {
            s32* modelCount = &gEntityModelCount;
            heap_free((*gCurrentEntityModelList)[index]);
            (*gCurrentEntityModelList)[index] = NULL;
            (*modelCount)--;
        }
    }
}

Referenced by btl_bonk_update(), delete_entity(), delete_entity_and_unload_data(), delete_shadow(), free_entity_model_by_ref(), and virtual_entity_delete_by_index().

◆ btl_cam_use_preset()

void btl_cam_use_preset ( s32 preset )

Definition at line 1919 of file camera.c.

                                    {
    if (!BattleCam_IsFrozen) {
        BattleCam_SetImmediately = FALSE;
        btl_cam_use_preset_impl(preset);
    }
}

◆ btl_cam_set_params()

void btl_cam_set_params	(	b16	skipRecalc,
		s16	boomLength,
		s16	vfovScale,
		s16	boomPitch,
		s32	boomYaw,
		s32	boomZOffset,
		s32	zoomPercent )

Definition at line 1939 of file camera.c.

                                                                                                                                     {
    Camera* camera = &gCameras[CAM_BATTLE];
 
    if (!BattleCam_IsFrozen) {
        camera->params.basic.skipRecalc = skipRecalc;
        camera->params.basic.dist = boomLength;
        camera->params.basic.fovScale = vfovScale;
        camera->params.basic.pitch = boomPitch;
        camera->params.basic.yaw = boomYaw;
        camera->params.basic.offsetY = boomZOffset * 256;
        camera->params.basic.zoomPercent = zoomPercent;
    }
}

Referenced by btl_state_update_celebration().

◆ btl_cam_set_zoffset()

void btl_cam_set_zoffset ( s16 zOffset )

Definition at line 1996 of file camera.c.

                                      {
    if (!BattleCam_IsFrozen) {
        BattleCam_BoomOffsetY = zOffset;
    }
}

Referenced by btl_state_update_change_partner().

◆ btl_cam_target_actor()

void btl_cam_target_actor ( s32 actorID )

Definition at line 1926 of file camera.c.

                                       {
    if (!BattleCam_IsFrozen) {
        BattleCam_SubjectActor = actorID;
    }
}

Referenced by btl_state_update_defeat(), btl_state_update_enemy_striking_first(), btl_state_update_first_strike(), btl_state_update_partner_move(), btl_state_update_partner_striking_first(), btl_state_update_player_move(), and btl_state_update_run_away().

◆ btl_cam_set_zoom()

void btl_cam_set_zoom ( s16 zoom )

Definition at line 1984 of file camera.c.

                                {
    if (!BattleCam_IsFrozen) {
        BattleCam_BoomLength = zoom;
    }
}

Referenced by btl_state_update_change_partner().

◆ btl_cam_move()

void btl_cam_move ( s16 moveTime )

Definition at line 1953 of file camera.c.

                                {
    if (!BattleCam_IsFrozen) {
        BattleCam_MoveTimeLeft = moveTime;
        if (gBattleStatus.camMovementScript != NULL) {
            restart_script(gBattleStatus.camMovementScript);
        }
    }
}

Referenced by btl_state_update_begin_partner_turn(), btl_state_update_begin_player_turn(), btl_state_update_celebration(), btl_state_update_end_player_turn(), btl_state_update_enemy_move(), btl_state_update_partner_move(), btl_state_update_peach_menu(), btl_state_update_player_menu(), btl_state_update_player_move(), and btl_state_update_twink_menu().

◆ btl_cam_disable_clamp_x()

void btl_cam_disable_clamp_x ( void )

Definition at line 2006 of file camera.c.

                                   {
    BattleCam_ClampPosX = FALSE;
}

◆ initialize_battle()

void initialize_battle ( void )

Definition at line 160 of file 16C8E0.c.

                             {
    PlayerData* playerData = &gPlayerData;
    BattleStatus* battleStatus = &gBattleStatus;
    Camera* tattleCam = &gCameras[CAM_TATTLE];
    HudElemID hid;
    s32 i;
 
    gBattleStatus.flags1 = 0;
    gBattleStatus.flags2 = 0;
    gBattleStatus.flags1 = 0;
    bSavedOverrideFlags = gOverrideFlags;
    gOverrideFlags &= ~GLOBAL_OVERRIDES_ENABLE_FLOOR_REFLECTION;
    gBattleStatus.inputBitmask = -1;
    gOverrideFlags &= ~GLOBAL_OVERRIDES_ENABLE_FLOOR_REFLECTION;
 
    for (i = 0; i < ARRAY_COUNT(battleStatus->pushInputBuffer); i++) {
        battleStatus->pushInputBuffer[i] = 0;
    }
 
    battleStatus->inputBufferPos = 0;
    battleStatus->holdInputBufferPos = 0;
    battleStatus->waitForState = BATTLE_STATE_0;
 
    for (i = 0; i < ARRAY_COUNT(battleStatus->enemyActors); i++) {
        battleStatus->enemyActors[i] = NULL;
    }
 
    battleStatus->playerActor = NULL;
    battleStatus->partnerActor = NULL;
 
    for (i = 0; i < ARRAY_COUNT(battleStatus->lastPlayerMenuSelection); i++) {
        battleStatus->lastPlayerMenuSelection[i] = -1;
        battleStatus->lastPartnerMenuSelection[i] = -1;
    }
 
    for (i = 0; i < ARRAY_COUNT(battleStatus->tattleFlags); i++) {
        battleStatus->tattleFlags[i] = 0;
    }
 
    if (gGameStatusPtr->peachFlags & PEACH_FLAG_IS_PEACH) {
        gBattleStatus.flags2 |= BS_FLAGS2_PEACH_BATTLE;
        increment_status_bar_disabled();
    } else {
        gBattleStatus.flags2 &= ~BS_FLAGS2_PEACH_BATTLE;
    }
 
    create_worker_scene(NULL, btl_render_actors);
    btl_popup_messages_init();
    create_action_command_ui_worker();
    set_windows_visible(WINDOW_GROUP_BATTLE);
    HPBarHID = hud_element_create(&HES_HPBar);
    hud_element_set_flags(HPBarHID, HUD_ELEMENT_FLAG_80);
 
    for (i = 0; i < ARRAY_COUNT(BtlStarPointTensHIDs); i++) {
        hid = BtlStarPointTensHIDs[i] = hud_element_create(&HES_ItemStarPoint);
        hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80 | HUD_ELEMENT_FLAG_DISABLED);
        hud_element_set_render_depth(hid, 20);
    }
 
    for (i = 0; i < ARRAY_COUNT(BtlStarPointShinesHIDs); i++) {
        hid = BtlStarPointShinesHIDs[i] = hud_element_create(&HES_StatusSPShine);
        hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80 | HUD_ELEMENT_FLAG_DISABLED);
        hud_element_set_render_depth(hid, 20);
    }
 
    for (i = 0; i < ARRAY_COUNT(BtlStarPointOnesHIDs); i++) {
        hid = BtlStarPointOnesHIDs[i] = hud_element_create(&HES_SmallStarPoint);
        hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80 | HUD_ELEMENT_FLAG_DISABLED);
        hud_element_set_render_depth(hid, 20);
    }
 
    tattleCam->fpDoPreRender = tattle_cam_pre_render;
    tattleCam->fpDoPostRender = tattle_cam_post_render;
 
    if (playerData->battlesCount < 9999) {
        playerData->battlesCount++;
    }
 
    bSavedPartner = playerData->curPartner;
    if (gBattleStatus.flags2 & BS_FLAGS2_PEACH_BATTLE) {
        playerData->curPartner = PARTNER_TWINK;
    }
}

Referenced by state_step_battle().

◆ dispatch_event_actor()

void dispatch_event_actor	(	Actor *	actor,
		s32	event )

Definition at line 103 of file 1A5830.c.

                                                   {
    Evt* handleEventScript = actor->handleEventScript;
    s32 onHitID = actor->handleEventScriptID;
 
    if (actor->handleEventSource != NULL) {
        Evt* newScript;
 
        actor->lastEventType = event;
        newScript = start_script(actor->handleEventSource, EVT_PRIORITY_A, EVT_FLAG_RUN_IMMEDIATELY);
        actor->handleEventScript = newScript;
        actor->handleEventScriptID = newScript->id;
        newScript->owner1.actorID = actor->actorID;
    }
 
    if (actor->takeTurnScript != NULL) {
        get_script_by_index(actor->takeTurnScriptID);
        kill_script_by_ID(actor->takeTurnScriptID);
        actor->takeTurnScript = NULL;
    }
 
    if (handleEventScript != NULL) {
        kill_script_by_ID(onHitID);
    }
}

Referenced by btl_state_update_9(), calc_enemy_damage_target(), calc_item_damage_enemy(), calc_partner_damage_enemy(), calc_partner_test_enemy(), calc_player_damage_enemy(), calc_player_test_enemy(), dispatch_damage_event_actor(), and dispatch_event_general().

◆ dispatch_damage_event_actor_1()

s32 dispatch_damage_event_actor_1	(	Actor *	actor,
		s32	damageAmount,
		s32	event )

Definition at line 893 of file 1A5830.c.

                                                                             {
    return dispatch_damage_event_actor(actor, damageAmount, event, TRUE);
}

Referenced by calc_enemy_damage_target().

◆ reset_battle_status()

void reset_battle_status ( void )

Definition at line 100 of file battle.c.

                               {
    gGameStatusPtr->demoBattleFlags = 0;
    gBattleState = BATTLE_STATE_0;
    gBattleSubState = BTL_SUBSTATE_INIT;
    gLastDrawBattleState = BATTLE_STATE_0;
    gCurrentBattlePtr = NULL;
    gCurrentBattleID = 0;
    gCurrentStagePtr = NULL;
    gCurrentStageID = 0;
    gOverrideBattlePtr = NULL;
}

Referenced by load_demo_battle(), load_map_by_IDs(), state_step_demo(), state_step_intro(), and state_step_startup().

◆ btl_show_variable_battle_message()

void btl_show_variable_battle_message	(	s32	messageIndex,
		s32	duration,
		s32	varValue )

Definition at line 601 of file popup_messages.c.

                                                                                    {
    PopupMessage* popup = btl_create_popup();
 
    if (popup != NULL) {
        popup->updateFunc = btl_update_message_popup;
        popup->renderUIFunc = btl_show_message_popup;
        popup->unk_00 = FALSE;
        popup->renderWorldFunc = NULL;
        popup->messageIndex = messageIndex;
        popup->duration = duration;
        popup->showMsgState = BTL_MSG_STATE_INIT;
        popup->needsInit = TRUE;
        popup->data.bonk = NULL;
        BattlePopupMessageVar = varValue;
        bPopupMessage = popup;
        ActionCommandTipVisible = FALSE;
        BattleMessage_BoxPosLocked = FALSE;
        BattleMessage_CurBoxPosY = 0;
#if !VERSION_JP
        BattleMessage_CurBoxOffsetY = 0;
#endif
    }
}

Referenced by btl_state_update_partner_menu(), btl_state_update_peach_menu(), btl_state_update_player_menu(), and btl_state_update_twink_menu().

◆ btl_is_popup_displayed()

s32 btl_is_popup_displayed ( void )

Definition at line 625 of file popup_messages.c.

                                 {
    return bPopupMessage != NULL;
}

Referenced by btl_main_menu_update(), btl_state_update_begin_player_turn(), btl_state_update_enemy_move(), btl_state_update_partner_menu(), btl_state_update_partner_move(), btl_state_update_peach_menu(), btl_state_update_player_menu(), btl_state_update_player_move(), and btl_state_update_twink_menu().

◆ btl_cam_use_preset_immediately()

void btl_cam_use_preset_immediately ( s32 preset )

Definition at line 1912 of file camera.c.

                                                {
    if (!BattleCam_IsFrozen) {
        BattleCam_SetImmediately = TRUE;
        btl_cam_use_preset_impl(preset);
    }
}

◆ inflict_status()

s32 inflict_status	(	Actor *	target,
		s32	statusTypeKey,
		s32	duration )

Definition at line 2084 of file 190B20.c.

                                                                   {
    BattleStatus* battleStatus = &gBattleStatus;
    EffectInstance* effect;
 
    switch (statusTypeKey) {
        case STATUS_KEY_FEAR:
        case STATUS_KEY_DIZZY:
        case STATUS_KEY_PARALYZE:
        case STATUS_KEY_SLEEP:
        case STATUS_KEY_FROZEN:
        case STATUS_KEY_STOP:
        case STATUS_KEY_POISON:
        case STATUS_KEY_SHRINK:
            if (target->actorID != ACTOR_PLAYER || (!is_ability_active(ABILITY_FEELING_FINE) &&
                !is_ability_active(ABILITY_BERSERKER) && battleStatus->hustleTurns == 0)) {
 
                if (target->actorID != ACTOR_PARTNER) {
                    if (target->debuff != statusTypeKey) {
                        target->statusAfflicted = statusTypeKey;
                    }
                    target->disableEffect->data.disableX->koDuration = 0;
                    target->debuff = statusTypeKey;
                    target->debuffDuration = duration;
                    if ((s8)duration > 9) {
                        target->debuffDuration = 9;
                    }
 
                    switch (statusTypeKey) {
                        case STATUS_KEY_FROZEN:
                            if (target->actorID != ACTOR_PARTNER) {
                                effect = target->icePillarEffect;
                                if (effect != NULL) {
                                    effect->flags |= FX_INSTANCE_FLAG_DISMISS;
                                }
                                target->icePillarEffect = fx_ice_pillar(0, target->curPos.x, target->curPos.y,
                                                            target->curPos.z, 1.0f, 0);
                                create_status_debuff(target->hudElementDataIndex, STATUS_KEY_FROZEN);
                            }
                            return TRUE;
                        case STATUS_KEY_SLEEP:
                            set_actor_pal_adjustment(target, ACTOR_PAL_ADJUST_SLEEP);
                            create_status_debuff(target->hudElementDataIndex, STATUS_KEY_SLEEP);
                            return TRUE;
                        case STATUS_KEY_PARALYZE:
                            set_actor_pal_adjustment(target, ACTOR_PAL_ADJUST_PARALYZE);
                            create_status_debuff(target->hudElementDataIndex, STATUS_KEY_PARALYZE);
                            return TRUE;
                        case STATUS_KEY_DIZZY:
                            create_status_debuff(target->hudElementDataIndex, STATUS_KEY_DIZZY);
                            return TRUE;
                        case STATUS_KEY_FEAR:
                            set_actor_pal_adjustment(target, ACTOR_PAL_ADJUST_FEAR);
                            create_status_debuff(target->hudElementDataIndex, STATUS_KEY_FEAR);
                            return TRUE;
                        case STATUS_KEY_POISON:
                            set_actor_pal_adjustment(target, ACTOR_PAL_ADJUST_POISON);
                            create_status_debuff(target->hudElementDataIndex, STATUS_KEY_POISON);
                            return TRUE;
                        case STATUS_KEY_SHRINK:
                            create_status_debuff(target->hudElementDataIndex, STATUS_KEY_SHRINK);
                            return TRUE;
                    }
                }
                return TRUE;
            } else {
                return FALSE;
            }
            break;
        case STATUS_KEY_STATIC:
            if (target->actorID != ACTOR_PARTNER) {
                target->staticStatus = statusTypeKey;
                target->staticDuration = duration;
                if ((s8)duration > 9) {
                    target->staticDuration = 9;
                }
                target->statusAfflicted = STATUS_KEY_STATIC;
                set_actor_pal_adjustment(target, ACTOR_PAL_ADJUST_STATIC);
                create_status_static(target->hudElementDataIndex, STATUS_KEY_STATIC);
            }
            return TRUE;
        case STATUS_KEY_STONE:
            if (target->actorID != ACTOR_PARTNER) {
                target->stoneStatus = STATUS_KEY_STONE;
                target->stoneDuration = duration;
                if ((s8)duration > 9) {
                    target->stoneDuration = 9;
                }
                target->statusAfflicted = STATUS_KEY_STONE;
            }
            return TRUE;
        case STATUS_KEY_DAZE:
            if (target->koStatus < statusTypeKey) {
                target->koStatus = STATUS_KEY_DAZE;
                target->koDuration = duration;
                if ((s8)duration > 9) {
                    target->koDuration = 9;
                }
                target->statusAfflicted = STATUS_KEY_DAZE;
            }
            return TRUE;
        case STATUS_KEY_TRANSPARENT:
            if (target->actorID != ACTOR_PARTNER) {
                target->transparentStatus = STATUS_KEY_TRANSPARENT;
                target->transparentDuration = duration;
                if ((s8)duration > 9) {
                    target->transparentDuration = 9;
                }
                target->statusAfflicted = STATUS_KEY_TRANSPARENT;
                create_status_transparent(target->hudElementDataIndex, STATUS_KEY_TRANSPARENT);
            }
            return TRUE;
        case 0:
        case STATUS_KEY_NORMAL:
        case STATUS_KEY_DEFAULT:
        default:
            return TRUE;
    }
}

Referenced by calc_item_damage_enemy(), dispatch_damage_event_partner(), inflict_partner_ko(), inflict_status_set_duration(), and try_inflict_status().

◆ try_inflict_status()

s32 try_inflict_status	(	Actor *	actor,
		s32	statusTypeKey,
		s32	statusKey )

Definition at line 2532 of file 190B20.c.

                                                                       {
    BattleStatus* battleStatus = &gBattleStatus;
    s32 chance;
    s32 duration;
 
    if (battleStatus->statusChance == STATUS_KEY_IGNORE_RES) {
        duration = battleStatus->statusDuration;
        duration += lookup_status_duration_mod(actor->statusTable, statusKey);
        return inflict_status_set_duration(actor, statusTypeKey, statusKey, duration);
    }
 
    duration = 0;
 
    if (actor->statusTable != NULL) {
        if (!(battleStatus->curAttackStatus & STATUS_FLAG_RIGHT_ON)) {
            chance = lookup_status_chance(actor->statusTable, statusTypeKey);
        } else {
            chance = lookup_status_chance(actor->statusTable, statusTypeKey);
            if (chance != 0) {
                chance = 100;
            }
        }
 
        if (chance > 0) {
            chance = (chance * battleStatus->statusChance) / 100;
            if (chance > 0 && chance >= rand_int(100)) {
                duration = 3;
                duration += lookup_status_duration_mod(actor->statusTable, statusKey);
            }
        }
    } else {
        duration = 3;
    }
 
    if (duration > 0) {
        if (battleStatus->curAttackStatus < 0) {
            duration = battleStatus->statusDuration;
            duration += lookup_status_duration_mod(actor->statusTable, statusKey);
            inflict_status(actor, statusTypeKey, duration);
        } else {
            inflict_status(actor, statusTypeKey, duration);
 
        }
    } else {
        duration = 0;
    }
    return duration;
}

Referenced by calc_enemy_damage_target().

◆ inflict_status_set_duration()

s32 inflict_status_set_duration	(	Actor *	actor,
		s32	statusTypeKey,
		s32	statusDurationKey,
		s32	duration )

Definition at line 2581 of file 190B20.c.

                                                                                                      {
    s32 statusDuration = 0;
 
    if (actor->statusTable == NULL || lookup_status_chance(actor->statusTable, statusTypeKey) > 0) {
        statusDuration = duration;
    }
 
    if (statusDuration > 0) {
        return inflict_status(actor, statusTypeKey, statusDuration);
    } else {
        return 0;
    }
}

Referenced by btl_state_update_normal_start(), and try_inflict_status().

◆ mdl_set_all_tint_type()

void mdl_set_all_tint_type ( s32 tintType )

Definition at line 4519 of file model.c.

                                         {
    ModelList* modelList = gCurrentModels;
    Model* model;
    s32 type = tintType; // weirdness here and the next line needed to match
    s32 i = tintType;
 
    for (i = 0; i < ARRAY_COUNT(*modelList); i++) {
        model = (*modelList)[i];
 
        if (model != NULL) {
            set_mdl_custom_gfx_set(model, CUSTOM_GFX_NONE, type);
        }
    }
}

Referenced by btl_state_update_celebration().

◆ load_model_animator_tree()

void load_model_animator_tree	(	s32	index,
		StaticAnimatorNode **	tree )

Definition at line 1171 of file animator.c.

                                                                    {
    ModelAnimator* animator = (*gCurrentAnimMeshListPtr)[index & ~BATTLE_ID_BIT];
    s32 nodeIDs[ARRAY_COUNT(animator->staticNodeIDs)];
 
    if (animator == NULL || animator->flags == 0) {
        return;
    }
 
    gAnimTreeRoot = tree;
    load_model_animator_node(*tree, animator, 0, nodeIDs);
    set_animator_tree_to_node_map(animator, nodeIDs, ARRAY_COUNT(animator->staticNodeIDs));
}

Referenced by create_shadow_from_data(), load_mesh_animator_tree(), and load_split_entity_data().

◆ inflict_partner_ko()

s32 inflict_partner_ko	(	Actor *	target,
		s32	statusTypeKey,
		s32	duration )

Definition at line 2203 of file 190B20.c.

                                                                       {
    if (statusTypeKey == STATUS_KEY_DAZE) {
        if (statusTypeKey != target->koStatus) {
            inflict_status(target, STATUS_KEY_DAZE, duration);
            sfx_play_sound(SOUND_INFLICT_KO);
        } else {
            target->koDuration += duration;
            if (target->koDuration > 9) {
                target->koDuration = 9;
            }
        }
    }
 
    return TRUE;
}

Referenced by calc_enemy_damage_target().

◆ get_defense()

s32 get_defense	(	Actor *	actor,
		s32 *	defenseTable,
		s32	elementFlags )

Definition at line 2219 of file 190B20.c.

                                                                   {
    s32 elemDefense;
    s32 minDefense = 255;
 
    if (defenseTable != NULL) {
 
        #define CHECK_DEFENSE(element) \
        if (elementFlags & DAMAGE_TYPE_##element) { \
            elemDefense = lookup_defense(defenseTable, ELEMENT_##element); \
            if (elemDefense < minDefense) { \
                minDefense = elemDefense; \
            } \
        } \
 
        CHECK_DEFENSE(FIRE);
        CHECK_DEFENSE(WATER);
        CHECK_DEFENSE(ICE);
        CHECK_DEFENSE(MAGIC);
        CHECK_DEFENSE(SMASH);
        CHECK_DEFENSE(JUMP);
        CHECK_DEFENSE(COSMIC);
        CHECK_DEFENSE(BLAST);
        CHECK_DEFENSE(SHOCK);
        CHECK_DEFENSE(QUAKE);
        CHECK_DEFENSE(THROW);
 
        #undef CHECK_DEFENSE
    }
 
    // If no element flags were set, fall back to normal defense.
    if (minDefense == 255) {
        elemDefense = lookup_defense(defenseTable, ELEMENT_NORMAL);
        if (elemDefense < 255) {
            minDefense = elemDefense;
        }
    }
 
    if (elementFlags & DAMAGE_TYPE_IGNORE_DEFENSE) {
        if (minDefense == 99) {
            // Immune
            minDefense = 999;
        } else if (minDefense > 0) {
            minDefense = 0;
        }
    }
 
    return minDefense;
}

Referenced by calc_enemy_damage_target(), calc_item_damage_enemy(), calc_partner_damage_enemy(), and calc_player_damage_enemy().

◆ btl_popup_messages_init()

void btl_popup_messages_init ( void )

Definition at line 271 of file popup_messages.c.

                                   {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(popupMessages); i++) {
        PopupMessage* popup = &popupMessages[i];
        popup->active = FALSE;
        popup->data.bonk = NULL;
    }
}

Referenced by initialize_battle().

◆ remove_all_effects()

void remove_all_effects ( void )

Definition at line 278 of file effects.c.

                              {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gEffectInstances); i++) {
        EffectInstance* effect = gEffectInstances[i];
 
        if (effect != NULL && effect->flags & FX_INSTANCE_FLAG_BATTLE) {
            if (effect->data.any != NULL) {
                general_heap_free(effect->data.any);
            }
            general_heap_free(effect);
            gEffectInstances[i] = NULL;
        }
    }
}

Referenced by btl_state_update_end_battle(), and btl_state_update_end_demo_battle().

◆ update_effects()

void update_effects ( void )

Definition at line 60 of file effects.c.

                          {
    if (!(gOverrideFlags & (GLOBAL_OVERRIDES_800 | GLOBAL_OVERRIDES_400))) {
        EffectSharedData* sharedData;
        s32 i;
 
        // reset free delay for each EffectSharedData touched in previous update
        for (i = 0, sharedData = gEffectSharedData; i < ARRAY_COUNT(gEffectSharedData); i++, sharedData++) {
            if (sharedData->flags & FX_SHARED_DATA_LOADED) {
                if (!(sharedData->flags & FX_SHARED_DATA_CAN_FREE)) {
                    sharedData->flags |= FX_SHARED_DATA_CAN_FREE;
                    sharedData->freeDelay = 3;
                }
            }
        }
 
        // update each EffectInstances
        for (i = 0; i < ARRAY_COUNT(gEffectInstances); i++) {
            EffectInstance* effectInstance = gEffectInstances[i];
 
            if (effectInstance != NULL && (effectInstance->flags & FX_INSTANCE_FLAG_ENABLED)) {
                effectInstance->shared->flags &= ~FX_SHARED_DATA_CAN_FREE;
 
                if (gGameStatusPtr->context != CONTEXT_WORLD) {
                    if (effectInstance->flags & FX_INSTANCE_FLAG_BATTLE) {
                        effectInstance->shared->update(effectInstance);
                        effectInstance->flags |= FX_INSTANCE_FLAG_HAS_UPDATED;
                    }
                } else {
                    if (!(effectInstance->flags & FX_INSTANCE_FLAG_BATTLE)) {
                        effectInstance->shared->update(effectInstance);
                        effectInstance->flags |= FX_INSTANCE_FLAG_HAS_UPDATED;
                    }
                }
            }
        }
 
        // free any EffectSharedData which haven't been used recently
        for (i = 0, sharedData = gEffectSharedData; i < ARRAY_COUNT(gEffectSharedData); i++, sharedData++) {
            if (sharedData->flags & FX_SHARED_DATA_LOADED) {
                if (sharedData->flags & FX_SHARED_DATA_CAN_FREE) {
                    if (sharedData->freeDelay != 0) {
                        sharedData->freeDelay--;
                    } else {
                        if (sharedData->graphics != NULL) {
                            general_heap_free(sharedData->graphics);
                            sharedData->graphics = NULL;
                        }
                        sharedData->flags = 0;
                        osUnmapTLB(i);
                    }
                }
            }
        }
    }
}

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().

◆ update_cameras()

void update_cameras ( void )

Definition at line 19 of file cam_main.c.

                          {
    s32 sx, sy, sz;
    s32 camID;
 
    for (camID = 0; camID < ARRAY_COUNT(gCameras); camID++) {
        Camera* cam = &gCameras[camID];
 
        if (cam->flags == 0 || cam->flags & CAMERA_FLAG_DISABLED) {
            continue;
        }
 
        gCurrentCamID = camID;
 
        switch (cam->updateMode) {
            default:
            case CAM_UPDATE_MINIMAL:
                update_camera_minimal(cam);
                break;
            case CAM_UPDATE_INTERP_POS:
                update_camera_interp_pos(cam);
                break;
            case CAM_UPDATE_FROM_ZONE:
                update_camera_zone_interp(cam);
                break;
            case CAM_UPDATE_NO_INTERP:
                update_camera_no_interp(cam);
                break;
            case CAM_UPDATE_UNUSED_RADIAL:
                update_camera_unused_radial(cam);
                break;
            case CAM_UPDATE_UNUSED_CONFINED:
                update_camera_unused_confined(cam);
                break;
            case CAM_UPDATE_UNUSED_LEADING:
                update_camera_unused_leading(cam);
                break;
        }
 
        guLookAtReflectF(cam->mtxViewPlayer, &gDisplayContext->lookAt, cam->lookAt_eye.x, cam->lookAt_eye.y, cam->lookAt_eye.z, cam->lookAt_obj.x, cam->lookAt_obj.y, cam->lookAt_obj.z, 0, 1.0f, 0);
 
        if (!(cam->flags & CAMERA_FLAG_ORTHO)) {
            if (cam->flags & CAMERA_FLAG_LEAD_PLAYER) {
                create_camera_leadplayer_matrix(cam);
            }
 
            guPerspectiveF(cam->mtxPerspective, &cam->perspNorm, cam->vfov, (f32) cam->viewportW / (f32) cam->viewportH, (f32) cam->nearClip, (f32) cam->farClip, 1.0f);
 
            if (cam->flags & CAMERA_FLAG_SHAKING) {
                guMtxCatF(cam->mtxViewShaking, cam->mtxPerspective, cam->mtxPerspective);
            }
 
            if (cam->flags & CAMERA_FLAG_LEAD_PLAYER) {
                guMtxCatF(cam->mtxViewLeading, cam->mtxPerspective, cam->mtxPerspective);
            }
 
            guMtxCatF(cam->mtxViewPlayer, cam->mtxPerspective, cam->mtxPerspective);
        } else {
            f32 w = cam->viewportW;
            f32 h = cam->viewportH;
 
            guOrthoF(cam->mtxPerspective, -w * 0.5, w * 0.5, -h * 0.5, h * 0.5, -1000.0f, 1000.0f, 1.0f);
        }
 
        get_screen_coords(CAM_DEFAULT, cam->targetPos.x, cam->targetPos.y, cam->targetPos.z, &sx, &sy, &sz);
        cam->targetScreenCoords.x = sx;
        cam->targetScreenCoords.y = sy;
        cam->targetScreenCoords.z = sz;
    }
 
    gCurrentCamID = CAM_DEFAULT;
}

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_title_screen(), and state_step_world().

◆ clear_render_tasks()

void clear_render_tasks ( void )

Definition at line 4534 of file model.c.

                              {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(ClearRenderTaskLists); i++) {
        RenderTaskLists[i] = ClearRenderTaskLists[i];
    }
 
    for (i = 0; i < ARRAY_COUNT(RenderTaskCount); i++) {
        RenderTaskCount[i] = 0;
    }
}

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

◆ clear_worker_list()

void clear_worker_list ( void )

Definition at line 10 of file worker.c.

                             {
    s32 i;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentWorkerListPtr = &gWorldWorkerList;
    } else {
        gCurrentWorkerListPtr = &gBattleWorkerList;
    }
 
    for (i = 0; i < MAX_WORKERS; i++) {
        (*gCurrentWorkerListPtr)[i] = NULL;
    }
}

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(), and state_step_startup().

◆ clear_printers()

void clear_printers ( void )

Definition at line 196 of file msg.c.

                          {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gMessagePrinters); i++) {
        initialize_printer(&gMessagePrinters[i], 0, 0);
    }
 
    gMsgBGScrollAmtX = 0;
    gMsgBGScrollAmtY = 0;
 
    for (i = 0; i < ARRAY_COUNT(gMessageMsgVars); i++) {
        gMessageMsgVars[i][0] = 0;
    }
 
    D_80151338 = NULL;
    gMsgGlobalWaveCounter = 0;
    load_font(0);
}

Referenced by load_demo_battle(), load_engine_data(), load_map_by_IDs(), state_init_title_screen(), state_step_demo(), state_step_intro(), and state_step_startup().

◆ clear_item_entity_data()

void clear_item_entity_data ( void )

Definition at line 243 of file item_entity.c.

                                  {
    s32 i;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentItemEntities = WorldItemEntities;
    } else {
        gCurrentItemEntities = BattleItemEntities;
    }
 
    for (i = 0; i < MAX_ITEM_ENTITIES; i++) {
        gCurrentItemEntities[i] = NULL;
    }
 
    ItemEntitiesCreated = 0;
    CoinSparkleCenterX = 0;
    CoinSparkleCenterY = 0;
    CoinSparkleCenterZ = 0;
    ItemEntityAlternatingSpawn = 0;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        ItemEntityRenderGroup = 0;
    }
 
    create_worker_scene(NULL, draw_item_entities);
    create_worker_frontUI(NULL, draw_ui_item_entities);
    isPickingUpItem = FALSE;
#if !VERSION_JP
    D_801565A8 = FALSE;
#endif
}

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

◆ clear_player_data()

void clear_player_data ( void )

Definition at line 55 of file inventory.c.

                             {
    PlayerData* playerData = &gPlayerData;
    s32 i;
 
    ShowingCoinCounter = FALSE;
    HidingCoinCounter = FALSE;
 
    playerData->curHP = 10;
    playerData->curMaxHP = 10;
    playerData->hardMaxHP = 10;
    playerData->curFP = 5;
    playerData->curMaxFP = 5;
    playerData->hardMaxFP = 5;
    playerData->maxBP = 3;
    playerData->level = 1;
    playerData->bootsLevel = 0;
    playerData->hammerLevel = -1;
    playerData->hasActionCommands = FALSE;
    playerData->coins = 0;
    playerData->starPieces = 0;
    playerData->starPoints = 0;
    playerData->unused_011 = 0;
    playerData->unused_288 = 0;
 
    playerData->merleeSpellType = MERLEE_SPELL_NONE;
    playerData->merleeCastsLeft = 0;
    playerData->merleeTurnCount = -1;
 
    playerData->maxStarPower = 0;
    playerData->starPower = 0;
    playerData->starBeamLevel = 0;
 
    playerData->curPartner = PARTNER_NONE;
 
    for (i = 0; i < ARRAY_COUNT(playerData->partners); i++) {
        playerData->partners[i].enabled = FALSE;
        playerData->partners[i].level = PARTNER_RANK_NORMAL;
        playerData->partners[i].unk_02[0] = 0;
        playerData->partners[i].unk_02[1] = 0;
        playerData->partners[i].unk_02[2] = 0;
    }
 
    for (i = 0; i < ARRAY_COUNT(playerData->keyItems); i++) {
        playerData->keyItems[i] = ITEM_NONE;
    }
 
    for (i = 0; i < ARRAY_COUNT(playerData->badges); i++) {
        playerData->badges[i] = ITEM_NONE;
    }
 
    for (i = 0; i < ARRAY_COUNT(playerData->invItems); i++) {
        playerData->invItems[i] = ITEM_NONE;
    }
 
    for (i = 0; i < ARRAY_COUNT(playerData->equippedBadges); i++) {
        playerData->equippedBadges[i] = ITEM_NONE;
    }
 
    for (i = 0; i < ARRAY_COUNT(playerData->storedItems); i++) {
        playerData->storedItems[i] = ITEM_NONE;
    }
 
    playerData->actionCommandAttempts = 0;
    playerData->actionCommandSuccesses = 0;
    playerData->hitsTaken = 0;
    playerData->hitsBlocked = 0;
    playerData->playerFirstStrikes = 0;
    playerData->enemyFirstStrikes = 0;
    playerData->powerBounces = 0;
    playerData->battlesCount = 0;
    playerData->battlesWon = 0;
    playerData->fleeAttempts = 0;
    playerData->battlesFled = 0;
    playerData->trainingsDone = 0;
    playerData->walkingStepsTaken = 0;
    playerData->runningStepsTaken = 0;
    playerData->idleFrameCounter = 0;
    playerData->totalCoinsEarned = 0;
    playerData->frameCounter = 0;
    playerData->quizzesAnswered = 0;
    playerData->quizzesCorrect = 0;
 
    for (i = 0; i < ARRAY_COUNT(playerData->partnerUnlockedTime); i++) {
        playerData->partnerUnlockedTime[i] = 0;
        playerData->partnerUsedTime[i] = 0;
    }
 
    playerData->droTreeHintTime = 0;
    playerData->starPiecesCollected = 0;
    playerData->jumpGamePlays = 0;
    playerData->jumpGameTotal = 0;
    playerData->jumpGameRecord = 0;
    playerData->smashGamePlays = 0;
    playerData->smashGameTotal = 0;
    playerData->smashGameRecord = 0;
}

Referenced by filemenu_yesno_handle_input(), load_demo_battle(), load_engine_data(), state_init_title_screen(), state_step_demo(), state_step_intro(), and state_step_startup().

◆ phys_update_jump()

void phys_update_jump ( void )

Definition at line 199 of file 7BB60.c.

                            {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    if (playerStatus->timeInAir != 0) {
        switch (playerStatus->actionState) {
            case ACTION_STATE_LAUNCH:
                handle_jumping_launch();
                return;
            case ACTION_STATE_LANDING_ON_SWITCH:
                handle_jumping_land_on_switch();
                return;
            case ACTION_STATE_BOUNCE:
                integrate_gravity();
                playerStatus->pos.y += playerStatus->gravityIntegrator[0];
                if (playerStatus->gravityIntegrator[0] <= 0.0f) {
                    record_jump_apex();
                    if (is_starting_conversation()) {
                        playerStatus->gravityIntegrator[0] = 0.154343f;
                        playerStatus->gravityIntegrator[1] = -0.35008f;
                        playerStatus->gravityIntegrator[2] = 0.0f;
                        playerStatus->gravityIntegrator[3] = 0.0f;
                    } else {
                        gravity_use_fall_parms();
                    }
                    integrate_gravity();
                    set_action_state(ACTION_STATE_FALLING);
                }
                return;
            case ACTION_STATE_HOP:
                playerStatus->gravityIntegrator[0] -= 4.5;
                playerStatus->pos.y += playerStatus->gravityIntegrator[0];
                if (playerStatus->gravityIntegrator[0] <= 0.0f) {
                    record_jump_apex();
                    gravity_use_fall_parms();
                    integrate_gravity();
                    set_action_state(ACTION_STATE_FALLING);
                }
                return;
            case ACTION_STATE_HIT_FIRE:
            case ACTION_STATE_HIT_LAVA:
                return;
            default:
                if (!(playerStatus->curButtons & BUTTON_A)) {
                    record_jump_apex();
                    set_action_state(ACTION_STATE_HOP);
                    integrate_gravity();
                    if (playerStatus->flags & PS_FLAG_ENTERING_BATTLE) {
                        playerStatus->gravityIntegrator[1] *= 0.5f;
                        playerStatus->gravityIntegrator[2] *= 0.5f;
                        playerStatus->gravityIntegrator[3] *= 0.5f;
                    }
                }
                break;
        }
    }
 
    integrate_gravity();
    if (playerStatus->gravityIntegrator[0] <= 0.0f) {
        record_jump_apex();
        gravity_use_fall_parms();
        integrate_gravity();
        set_action_state(ACTION_STATE_FALLING);
    }
 
    if (playerStatus->gravityIntegrator[0] > playerStatus->maxJumpSpeed) {
        playerStatus->gravityIntegrator[0] = playerStatus->maxJumpSpeed;
    }
    playerStatus->pos.y += playerStatus->gravityIntegrator[0];
}

Referenced by phys_update_standard().

◆ phys_update_falling()

void phys_update_falling ( void )

Definition at line 316 of file 7BB60.c.

                               {
    if (gPlayerStatus.actionState != ACTION_STATE_LANDING_ON_SWITCH
    && gPlayerStatus.actionState != ACTION_STATE_BOUNCE
    ) {
        s32 colliderID;
        gPlayerStatus.pos.y = player_check_collision_below(player_fall_distance(), &colliderID);
        player_handle_floor_collider_type(colliderID);
    }
}

Referenced by phys_update_standard().

◆ check_input_midair_jump()

void check_input_midair_jump ( void )

Definition at line 1079 of file 7BB60.c.

                                   {
    if (!(gPlayerStatus.flags & (PS_FLAG_SCRIPTED_FALL | PS_FLAG_SLIDING | PS_FLAG_FLYING))
        && !(gPlayerStatus.animFlags & (PA_FLAG_8BIT_MARIO | PA_FLAG_USING_WATT))
        && gPlayerStatus.peakJumpTime >= 6
        && gPlayerStatus.timeInAir < 18
        && gPlayerStatus.pressedButtons & BUTTON_A
    ) {
        switch (gPlayerData.bootsLevel) {
            case 0:
                break;
            case 1:
                set_action_state(ACTION_STATE_SPIN_JUMP);
                gPlayerStatus.flags |= PS_FLAG_FLYING;
                break;
            case 2:
                set_action_state(ACTION_STATE_TORNADO_JUMP);
                gPlayerStatus.flags |= PS_FLAG_FLYING;
                break;
        }
    }
}

Referenced by phys_update_standard().

◆ collision_check_player_overlaps()

void collision_check_player_overlaps ( void )

Definition at line 813 of file 7BB60.c.

                                           {
    PlayerStatus* playerStatus = &gPlayerStatus;
    f32 overlapPush = playerStatus->overlapPushAmount;
 
    if (overlapPush != 0.0f) {
        f32 x = playerStatus->pos.x;
        f32 y = playerStatus->pos.y;
        f32 z = playerStatus->pos.z;
 
        player_test_lateral_overlap(PLAYER_COLLISION_0, &gPlayerStatus, &x, &y, &z, overlapPush, playerStatus->overlapPushYaw);
 
        overlapPush -= playerStatus->runSpeed / 10.0f;
        playerStatus->pos.x = x;
        playerStatus->pos.y = y;
        playerStatus->pos.z = z;
 
        if (overlapPush < 0.0f) {
            overlapPush = 0.0f;
        }
 
        playerStatus->overlapPushAmount = overlapPush;
    }
}

Referenced by phys_update_standard().

◆ update_player_input()

void update_player_input ( void )

Definition at line 22 of file 7B440.c.

                               {
    PlayerStatus* playerStatus = &gPlayerStatus;
    s32 inputBufPos = playerStatus->inputBufPos;
 
    playerStatus->stickAxis[0] = gGameStatusPtr->stickX[0];
    playerStatus->stickAxis[1] = gGameStatusPtr->stickY[0];
    playerStatus->curButtons = gGameStatusPtr->curButtons[0];
    playerStatus->pressedButtons = gGameStatusPtr->pressedButtons[0];
    playerStatus->heldButtons = gGameStatusPtr->heldButtons[0];
 
    inputBufPos++;
    if (inputBufPos >= 10) {
        inputBufPos = 0;
    }
 
    playerStatus->stickXBuffer[inputBufPos] = playerStatus->stickAxis[0];
    playerStatus->stickYBuffer[inputBufPos] = playerStatus->stickAxis[1];
    playerStatus->curButtonsBuffer[inputBufPos] = playerStatus->curButtons;
    playerStatus->pressedButtonsBuffer[inputBufPos] = playerStatus->pressedButtons;
    playerStatus->heldButtonsBuffer[inputBufPos] = playerStatus->heldButtons;
    playerStatus->inputBufPos = inputBufPos;
 
    if (playerStatus->flags & (PS_FLAG_INPUT_DISABLED | PS_FLAG_NO_STATIC_COLLISION)) {
        playerStatus->stickAxis[0] = 0;
        playerStatus->stickAxis[1] = 0;
        playerStatus->curButtons = 0;
        playerStatus->pressedButtons = 0;
        playerStatus->heldButtons = 0;
    }
 
    if (playerStatus->animFlags & PA_FLAG_FORCE_USE_PARTNER) {
        playerStatus->animFlags |= PA_FLAG_PARTNER_USAGE_FORCED;
        playerStatus->pressedButtons |= 4;
    }
}

Referenced by update_player().

◆ phys_update_action_state()

void phys_update_action_state ( void )

Definition at line 112 of file 7E9D0.c.

                                    {
    PlayerStatus* playerStatus = &gPlayerStatus;
    PlayerSpinState* playerSpinState = &gPlayerSpinState;
 
    if (!(playerStatus->flags & PS_FLAG_ENTERING_BATTLE)) {
        playerStatus->flags &= ~PS_FLAG_TIME_STOPPED;
    }
 
    if (playerStatus->animFlags & PA_FLAG_USING_PEACH_PHYSICS) {
        phys_peach_update();
        return;
    }
 
    if (playerStatus->camResetDelay != 0) {
        playerStatus->camResetDelay--;
        if (playerStatus->camResetDelay == 0) {
            gCameras[CAM_DEFAULT].moveFlags |= CAMERA_MOVE_ACCEL_INTERP_Y;
        }
    }
 
    // if midair, look for velocity inflection
    if (playerStatus->timeInAir != 0) {
        if (playerStatus->gravityIntegrator[0] <= 0.0f && LastMidairPlayerVelY > 0.0f) {
            playerStatus->peakJumpTime = playerStatus->timeInAir;
        }
        LastMidairPlayerVelY = playerStatus->gravityIntegrator[0];
    }
 
    calculate_camera_yinterp_rate();
 
    if (playerSpinState->stopSoundTimer != 0) {
        playerSpinState->stopSoundTimer--;
        if (playerSpinState->stopSoundTimer == 0) {
            playerStatus->animFlags &= ~PA_FLAG_SPINNING;
            if (playerSpinState->spinSoundID != 0) {
                sfx_stop_sound(playerSpinState->spinSoundID);
            }
        }
    }
 
    do {
        s32 actionState = playerStatus->actionState;
 
        if (actionState == ACTION_STATE_IDLE || actionState == ACTION_STATE_WALK || actionState == ACTION_STATE_RUN) {
            s32 cond;
 
            if (!(playerStatus->flags & PS_FLAG_INPUT_DISABLED)) {
                cond = check_conversation_trigger();
            } else {
                cond = FALSE;
            }
 
            if ((gPartnerStatus.partnerActionState == PARTNER_ACTION_NONE) && !(playerStatus->flags & PS_FLAG_PAUSED) && cond) {
                set_action_state(ACTION_STATE_TALK);
            }
            check_input_spin();
        }
 
        Action* action = &PlayerActionsTable[gPlayerStatus.actionState];
 
        if (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED) {
            if (action->dmaStart != NULL && action->dmaStart != LastLoadedActionOffset) {
                LastLoadedActionOffset = action->dmaStart;
                dma_copy(action->dmaStart, action->dmaEnd, PLAYER_ACTION_VRAM_DEF);
            }
        }
        action->update();
    } while (playerStatus->flags & PS_FLAG_ACTION_STATE_CHANGED);
}

Referenced by phys_update_lava_reset(), phys_update_standard(), and update_player().

◆ collision_main_lateral()

void collision_main_lateral ( void )

Definition at line 494 of file 7BB60.c.

                                  {
    PlayerStatus* playerStatus = &gPlayerStatus;
    CollisionStatus* collisionStatus = &gCollisionStatus;
    f32 playerX, playerY, playerZ;
    f32 test1X, test1Y, test1Z;
    f32 test2X, test2Y, test2Z;
    f32 yaw;
    f32 yaw2;
    f32 speed;
    f32 sinTheta;
    f32 cosTheta;
    s32 result;
    s32 test1;
    s32 test2;
    f32 xBump;
    f32 zBump;
 
    gCollisionStatus.pushingAgainstWall = NO_COLLIDER;
    if (playerStatus->flags & PS_FLAG_CUTSCENE_MOVEMENT) {
        speed = playerStatus->curSpeed;
        if (playerStatus->flags & PS_FLAG_ENTERING_BATTLE) {
            speed *= 0.5f;
        }
        add_vec2D_polar(&playerStatus->pos.x, &playerStatus->pos.z, speed, playerStatus->heading);
        return;
    }
 
    switch (playerStatus->actionState) {
        case ACTION_STATE_STEP_UP:
            collision_check_player_intersecting_world(PLAYER_COLLISION_0, 0,
                playerStatus->spriteFacingAngle - 90.0f + gCameras[gCurrentCameraID].curYaw);
            break;
        case ACTION_STATE_RIDE:
            if (get_current_partner_id() == PARTNER_BOW) {
                playerStatus->pos.x += playerStatus->pushVel.x;
                playerStatus->pos.y += playerStatus->pushVel.y;
                playerStatus->pos.z += playerStatus->pushVel.z;
 
                if (playerStatus->pushVel.x != 0.0f ||
                    playerStatus->pushVel.y != 0.0f ||
                    playerStatus->pushVel.z != 0.0f)
                {
                    gCameras[CAM_DEFAULT].targetPos.x = playerStatus->pos.x;
                    gCameras[CAM_DEFAULT].targetPos.y = playerStatus->pos.y;
                    gCameras[CAM_DEFAULT].targetPos.z = playerStatus->pos.z;
                    if (playerStatus->curAlpha != 128) {
                        collision_check_player_intersecting_world(PLAYER_COLLISION_0, 0,
                            atan2(0.0f, 0.0f, playerStatus->pushVel.x, playerStatus->pushVel.z));
                    }
                }
            }
            break;
        case ACTION_STATE_SPIN_POUND:
        case ACTION_STATE_TORNADO_POUND:
            playerStatus->pos.x += playerStatus->pushVel.x;
            playerStatus->pos.y += playerStatus->pushVel.y;
            playerStatus->pos.z += playerStatus->pushVel.z;
            if (playerStatus->pushVel.x != 0.0f ||
                playerStatus->pushVel.y != 0.0f ||
                playerStatus->pushVel.z != 0.0f)
            {
                gCameras[CAM_DEFAULT].targetPos.x = playerStatus->pos.x;
                gCameras[CAM_DEFAULT].targetPos.y = playerStatus->pos.y;
                gCameras[CAM_DEFAULT].targetPos.z = playerStatus->pos.z;
            }
            if (playerStatus->pushVel.x != 0.0f ||
                playerStatus->pushVel.y != 0.0f ||
                playerStatus->pushVel.z != 0.0f)
            {
                collision_check_player_intersecting_world(PLAYER_COLLISION_0, 0,
                    playerStatus->spriteFacingAngle - 90.0f + gCameras[gCurrentCameraID].curYaw);
            }
            break;
        case ACTION_STATE_HAMMER:
            playerStatus->pos.x += playerStatus->pushVel.x;
            playerStatus->pos.y += playerStatus->pushVel.y;
            playerStatus->pos.z += playerStatus->pushVel.z;
            if (playerStatus->pushVel.x != 0.0f ||
                playerStatus->pushVel.y != 0.0f ||
                playerStatus->pushVel.z != 0.0f)
            {
                gCameras[CAM_DEFAULT].targetPos.x = playerStatus->pos.x;
                gCameras[CAM_DEFAULT].targetPos.y = playerStatus->pos.y;
                gCameras[CAM_DEFAULT].targetPos.z = playerStatus->pos.z;
            }
 
            playerX = playerStatus->pos.x;
            playerY = playerStatus->pos.y;
            playerZ = playerStatus->pos.z;
            if (playerStatus->curSpeed != 0.0f) {
                yaw = playerStatus->targetYaw;
            } else {
                yaw = playerStatus->spriteFacingAngle - 90.0f + gCameras[gCurrentCameraID].curYaw;
            }
            collisionStatus->curWall =
                player_test_move_with_slipping(playerStatus, &playerX, &playerY, &playerZ,
                                               playerStatus->colliderDiameter * 0.5f, yaw);
 
            if (playerStatus->pushVel.x != 0.0f ||
                playerStatus->pushVel.y != 0.0f ||
                playerStatus->pushVel.z != 0.0f)
            {
                collision_check_player_intersecting_world(PLAYER_COLLISION_0, 0,
                    playerStatus->spriteFacingAngle - 90.0f + gCameras[gCurrentCameraID].curYaw);
            }
            break;
        default:
            if (!(playerStatus->flags & PS_FLAG_FLYING)) {
                speed = 0.0f;
                if (!(playerStatus->flags & (PS_FLAG_SCRIPTED_FALL | PS_FLAG_INPUT_DISABLED))) {
                    player_input_to_move_vector(&yaw, &speed);
                    if (!(playerStatus->animFlags & PA_FLAG_SPINNING)) {
                        speed *= 0.03125f;
                        if (!(playerStatus->flags & (PS_FLAG_FALLING | PS_FLAG_JUMPING))) {
                            speed *= 0.25;
                        }
                        if (playerStatus->actionState == ACTION_STATE_LAUNCH) {
                            speed *= 1.5;
                        }
                        if (playerStatus->flags & PS_FLAG_ENTERING_BATTLE) {
                            speed *= 0.5f;
                        }
                    }
                    sin_cos_rad(DEG_TO_RAD(yaw), &sinTheta, &cosTheta);
 
                    if (playerStatus->actionState == ACTION_STATE_PUSHING_BLOCK) {
                        if (fabsf(sinTheta) > fabsf(cosTheta)) {
                            xBump = speed * sinTheta;
                            zBump = 0.0f;
                        } else {
                            xBump = 0.0f;
                            zBump = -speed * cosTheta;
                        }
                    } else if (!(playerStatus->animFlags & PA_FLAG_SPINNING)) {
                        xBump = speed * sinTheta;
                        zBump = -speed * cosTheta;
                    } else {
                        xBump = 0.0f;
                        zBump = 0.0f;
                    }
 
                    sin_cos_rad(DEG_TO_RAD(playerStatus->targetYaw), &sinTheta, &cosTheta);
                    speed = playerStatus->curSpeed;
                    if (playerStatus->flags & PS_FLAG_ENTERING_BATTLE) {
                        speed *= 0.5f;
                    }
                    playerX = xBump + (speed * sinTheta);
                    playerZ = zBump - (speed * cosTheta);
                    yaw = atan2(0.0f, 0.0f, playerX, playerZ);
                    speed = sqrtf(SQ(playerX) + SQ(playerZ));
                    if (playerStatus->flags & (PS_FLAG_FALLING | PS_FLAG_JUMPING)) {
                        if (speed > playerStatus->runSpeed) {
                            speed = playerStatus->runSpeed;
                        }
                    }
                }
 
                playerStatus->pos.x += playerStatus->pushVel.x;
                playerStatus->pos.z += playerStatus->pushVel.z;
                if (playerStatus->timeInAir == 0) {
                    playerStatus->pos.y += playerStatus->pushVel.y;
                }
 
                if (
                    playerStatus->pushVel.x != 0.0f ||
                    playerStatus->pushVel.y != 0.0f ||
                    playerStatus->pushVel.z != 0.0f)
                {
                    gCameras[CAM_DEFAULT].targetPos.x = playerStatus->pos.x;
                    gCameras[CAM_DEFAULT].targetPos.y = playerStatus->pos.y;
                    gCameras[CAM_DEFAULT].targetPos.z = playerStatus->pos.z;
                }
 
                playerX = playerStatus->pos.x;
                playerY = playerStatus->pos.y;
                playerZ = playerStatus->pos.z;
                result = player_test_move_with_slipping(playerStatus, &playerX, &playerY, &playerZ,
                                                        playerStatus->colliderDiameter * 0.5f, playerStatus->targetYaw);
                if (speed == 0.0f && result <= NO_COLLIDER) {
                    yaw2 = playerStatus->spriteFacingAngle - 90.0f + gCameras[gCurrentCameraID].curYaw;
                    sin_cos_rad(DEG_TO_RAD(yaw2 + 180.0f), &sinTheta, &cosTheta);
                    playerX = playerStatus->pos.x + (sinTheta * playerStatus->colliderDiameter * 0.5f);
                    playerY = playerStatus->pos.y;
                    playerZ = playerStatus->pos.z - (cosTheta * playerStatus->colliderDiameter * 0.5f);
                    result = player_test_move_with_slipping(playerStatus, &playerX, &playerY, &playerZ,
                                                            playerStatus->colliderDiameter, yaw2);
                }
                collisionStatus->curWall = result;
                if (!(playerStatus->flags & PS_FLAG_MOVEMENT_LOCKED) && playerStatus->actionState != ACTION_STATE_HAMMER) {
                    if (speed == 0.0f) {
                        collision_check_player_intersecting_world(PLAYER_COLLISION_0, 0,
                            playerStatus->spriteFacingAngle - 90.0f + gCameras[gCurrentCameraID].curYaw);
                        break;
                    }
 
                    playerX = playerStatus->pos.x;
                    playerZ = playerStatus->pos.z;
                    playerY = playerStatus->pos.y;
                    yaw2 = yaw;
 
                    if (speed > 4.0f) {
                        result = player_test_move_with_slipping(playerStatus, &playerX, &playerY, &playerZ, 4.0f, yaw2);
                        if (result <= NO_COLLIDER) {
                            result = player_test_move_with_slipping(playerStatus, &playerX, &playerY, &playerZ, speed - 4.0f, yaw2);
                        }
                        collisionStatus->pushingAgainstWall = result;
                    } else {
                        collisionStatus->pushingAgainstWall =
                            player_test_move_with_slipping(playerStatus, &playerX, &playerY, &playerZ, speed, yaw2);
                    }
 
                    test1X = playerX;
                    test1Y = playerY;
                    test1Z = playerZ;
                    yaw = clamp_angle(yaw2 - 35.0);
                    test1 = player_test_lateral_overlap(PLAYER_COLLISION_0, playerStatus, &test1X, &test1Y, &test1Z, 0.0f, yaw);
                    test2X = playerX;
                    test2Z = playerY;
                    test2Y = playerZ;
                    yaw = clamp_angle(yaw2 + 35.0);
                    test2 = player_test_lateral_overlap(PLAYER_COLLISION_0, playerStatus, &test2X, &test2Z, &test2Y, 0.0f, yaw);
 
                    if (test1 <= NO_COLLIDER) {
                        if (test2 <= NO_COLLIDER) {
                            playerStatus->pos.x = playerX;
                            playerStatus->pos.z = playerZ;
                        } else {
                            playerStatus->pos.x = test1X;
                            playerStatus->pos.z = test1Z;
                        }
                    } else if (test2 <= NO_COLLIDER) {
                        playerStatus->pos.x = test2X;
                        playerStatus->pos.z = test2Y;
                    }
 
                    if (playerStatus->enableCollisionOverlapsCheck == 0) {
                        if (playerStatus->animFlags & PA_FLAG_SPINNING) {
                            yaw2 = playerStatus->targetYaw;
                        } else {
                            yaw2 = playerStatus->spriteFacingAngle - 90.0f + gCameras[gCurrentCameraID].curYaw;
                        }
                        if (collision_check_player_intersecting_world(PLAYER_COLLISION_0, 0, yaw2) <= NO_COLLIDER) {
                            collision_check_player_intersecting_world(PLAYER_COLLISION_1, playerStatus->colliderHeight * 0.75f, yaw2);
                        }
                    }
                }
            }
            break;
        case ACTION_STATE_LANDING_ON_SWITCH:
        case ACTION_STATE_LAND:
        case ACTION_STATE_STEP_DOWN_LAND:
        case ACTION_STATE_TORNADO_JUMP:
        case ACTION_STATE_SLIDING:
        case ACTION_STATE_HIT_FIRE:
        case ACTION_STATE_HIT_LAVA:
        case ACTION_STATE_USE_SNEAKY_PARASOL:
        case ACTION_STATE_USE_SPRING:
            break;
    }
}

Referenced by phys_update_lava_reset(), phys_update_standard(), and update_player().

◆ player_surface_spawn_fx()

void player_surface_spawn_fx ( void )

Definition at line 42 of file surfaces.c.

                                   {
    s32 surfaceType = SURFACE_TYPE_DEFAULT;
 
    if (gPlayerStatus.actionState == ACTION_STATE_JUMP) {
        surfaceType = PrevSurfaceType;
    }
 
    PrevSurfaceType = get_collider_flags((u16)gCollisionStatus.curFloor) & COLLIDER_FLAGS_SURFACE_TYPE_MASK;
 
    if (gPlayerStatus.actionState != ACTION_STATE_JUMP) {
        surfaceType = PrevSurfaceType;
    }
 
    if (gPlayerStatus.actionState == ACTION_STATE_LAND && gPlayerStatus.flags & PS_FLAG_ACTION_STATE_CHANGED) {
        LandedTimeInAir = PrevTimeInAir;
    }
 
    PrevTimeInAir = gPlayerStatus.timeInAir;
 
    switch (surfaceType) {
        case SURFACE_TYPE_FLOWERS:
            player_surface_spawn_flower_fx();
            break;
        case SURFACE_TYPE_CLOUD:
            player_surface_spawn_cloud_fx();
            break;
        case SURFACE_TYPE_SNOW:
            player_surface_spawn_snow_fx();
            break;
        case SURFACE_TYPE_HEDGES:
            player_surface_spawn_hedges_fx();
            break;
        case SURFACE_TYPE_WATER:
            player_surface_spawn_water_fx();
            break;
        default:
            player_surface_spawn_basic_fx();
            break;
    }
}

Referenced by player_jump(), and update_player().

◆ check_input_open_menus()

void check_input_open_menus ( void )

Definition at line 191 of file menus.c.

                                  {
    static s16 SwappedWorldMenus;
 
    PartnerStatus* partnerStatus;
    PlayerStatus* playerStatus;
    PlayerData* playerData;
    PopupMenu* popup;
    s32 flags;
    s32 numEntries;
    s32 pressedButtons;
    s32 currentButtons;
    s8* partnerActionState;
 
    partnerStatus = &gPartnerStatus;
    playerStatus = &gPlayerStatus;
    playerData = &gPlayerData;
    popup = &WorldPopupMenu;
 
    if (gGameStatusPtr->debugScripts != DEBUG_SCRIPTS_NONE
        || (gGameStatusPtr->peachFlags & PEACH_FLAG_IS_PEACH)
        || evt_get_variable(NULL, GB_StoryProgress) == STORY_INTRO
    ) {
        return;
    }
 
    if (partnerStatus->partnerActionState != PARTNER_ACTION_NONE &&
        (partnerStatus->actingPartner == PARTNER_SUSHIE ||
         partnerStatus->actingPartner == PARTNER_LAKILESTER ||
         partnerStatus->actingPartner == PARTNER_BOW))
    {
        currentButtons = partnerStatus->curButtons;
        pressedButtons = partnerStatus->pressedButtons;
    } else {
        currentButtons = playerStatus->curButtons;
        pressedButtons = playerStatus->pressedButtons;
    }
    partnerActionState = &partnerStatus->partnerActionState;
 
    // prevent opening popup menus during the epilogue
    if (evt_get_variable(NULL, GB_StoryProgress) >= STORY_EPILOGUE) {
        currentButtons &= ~(BUTTON_C_LEFT | BUTTON_C_RIGHT);
        pressedButtons &= ~(BUTTON_C_LEFT | BUTTON_C_RIGHT);
    }
 
    switch (WorldMenuState) {
        case WORLD_MENU_STATE_NONE:
            if (can_open_world_menu(currentButtons, pressedButtons)) {
                WorldMenuType = WORLD_MENU_USE_ITEM;
                if (pressedButtons & BUTTON_C_RIGHT) {
                    WorldMenuType = WORLD_MENU_CHANGE_PARTNER;
                }
                if (pressedButtons & BUTTON_START) {
                    WorldMenuType = WORLD_MENU_PAUSE;
                }
                SwappedWorldMenus = FALSE;
block_17:
                switch (WorldMenuType) {
                    case WORLD_MENU_CHANGE_PARTNER:
                        if (playerStatus->flags & PS_FLAG_NO_CHANGE_PARTNER) {
                            sfx_play_sound(SOUND_MENU_ERROR);
                            if (SwappedWorldMenus) {
                                reset_outta_sight_alpha_on_menu_close();
                                playerStatus->flags &= ~PS_FLAG_PAUSED;
                                gOverrideFlags &= ~GLOBAL_OVERRIDES_40;
                                set_time_freeze_mode(TIME_FREEZE_NONE);
                            }
                        } else {
                            numEntries = setup_partner_popup(popup);
                            if (numEntries == 0) {
                                return;
                            }
                            popup->numEntries = numEntries;
                            popup->popupType = POPUP_MENU_SWITCH_PARTNER;
                            popup->initialPos = MenuIndexFromPartnerID[playerData->curPartner] - 1;
                            break;
                        }
                        return;
                    case WORLD_MENU_USE_ITEM:
                        numEntries = setup_item_popup(popup);
                        if (numEntries == 0) {
                            return;
                        }
                        popup->popupType = POPUP_MENU_USE_ITEM;
                        popup->numEntries = numEntries;
                        popup->initialPos = 0;
                        break;
                }
                playerStatus->flags |= PS_FLAG_PAUSED;
                disable_player_input();
                partner_disable_input();
                WorldMenuDelay = 3;
                WorldMenuState = WORLD_MENU_STATE_DELAY;
                OpenMenuDisableCount = playerStatus->inputDisabledCount;
            }
            break;
        case WORLD_MENU_STATE_DELAY:
            flags = ~PS_FLAG_PAUSED;
            if (!should_cancel_open_world_menu() || is_picking_up_item() || OpenMenuDisableCount < playerStatus->inputDisabledCount != 0) {
                playerStatus->flags &= flags;
                enable_player_input();
                partner_enable_input();
                WorldMenuState = WORLD_MENU_STATE_NONE;
                if (SwappedWorldMenus) {
                    reset_outta_sight_alpha_on_menu_close();
                    playerStatus->flags &= ~PS_FLAG_PAUSED;
                    gOverrideFlags &= ~GLOBAL_OVERRIDES_40;
                    set_time_freeze_mode(TIME_FREEZE_NONE);
                }
            } else {
                WorldMenuDelay--;
                if (WorldMenuDelay == 0) {
                    WorldMenuState = WORLD_MENU_STATE_OPEN;
                    gOverrideFlags |= GLOBAL_OVERRIDES_40;
                }
            }
            break;
        case WORLD_MENU_STATE_OPEN:
            if (WorldMenuType == WORLD_MENU_PAUSE) {
                set_game_mode(GAME_MODE_PAUSE);
                sfx_play_sound(SOUND_MENU_OPEN);
                WorldMenuDelay = 10;
                WorldMenuState = WORLD_MENU_STATE_UNPAUSE;
                return;
            }
            create_standard_popup_menu(popup);
            set_time_freeze_mode(TIME_FREEZE_POPUP_MENU);
            if (*partnerActionState == PARTNER_ACTION_NONE) {
                set_action_state(ACTION_STATE_IDLE);
            }
            WorldMenuState++;
            break;
        case WORLD_MENU_STATE_HOLD:
            if (popup->result != POPUP_RESULT_INVALID) {
                WorldPopupResult = popup->result;
                if (WorldPopupResult != POPUP_RESULT_CHOOSING) {
                    hide_popup_menu();
                    WorldMenuDelay = 15;
                    WorldMenuState++;
                }
            }
            break;
        case WORLD_MENU_STATE_CLOSE:
            WorldMenuDelay--;
            if (WorldMenuDelay != 0) {
                break;
            }
            destroy_popup_menu();
            WorldMenuState = WORLD_MENU_STATE_NONE;
            enable_player_input();
            partner_enable_input();
            if (WorldPopupResult == POPUP_RESULT_SWAP_MENU) {
                if ((setup_partner_popup(popup) == 0) || (setup_item_popup(popup) == 0)) {
                    WorldPopupResult = POPUP_RESULT_CANCEL;
                } else {
                    // swap to other menu
                    switch (WorldMenuType) {
                        case WORLD_MENU_CHANGE_PARTNER:
                            WorldMenuType = WORLD_MENU_USE_ITEM;
                            break;
                        case WORLD_MENU_USE_ITEM:
                            WorldMenuType = WORLD_MENU_CHANGE_PARTNER;
                            break;
                    }
                    SwappedWorldMenus = TRUE;
                    goto block_17; // TODO required to match
                }
            }
 
            if (WorldPopupResult != POPUP_RESULT_CANCEL) {
                switch (WorldMenuType) {
                    case WORLD_MENU_CHANGE_PARTNER:
                        switch_to_partner(popup->userIndex[WorldPopupResult - 1]);
                        break;
                    case WORLD_MENU_USE_ITEM:
                        use_consumable(popup->userIndex[WorldPopupResult - 1]);
#ifndef VERSION_JP
                        gOverrideFlags |= GLOBAL_OVERRIDES_CANT_PICK_UP_ITEMS;
#endif
                        break;
                }
            }
            reset_outta_sight_alpha_on_menu_close();
            playerStatus->flags &= ~PS_FLAG_PAUSED;
            gOverrideFlags &= ~GLOBAL_OVERRIDES_40;
            set_time_freeze_mode(TIME_FREEZE_NONE);
            break;
        case WORLD_MENU_STATE_UNPAUSE:
            WorldMenuDelay--;
            if (WorldMenuDelay == 0) {
                reset_outta_sight_alpha_on_menu_close();
                WorldMenuState = WORLD_MENU_STATE_NONE;
                playerStatus->flags &= ~PS_FLAG_PAUSED;
                gOverrideFlags &= ~GLOBAL_OVERRIDES_40;
                enable_player_input();
                partner_enable_input();
            }
            break;
    }
}

Referenced by update_player().

◆ check_input_status_bar()

void check_input_status_bar ( void )

Definition at line 391 of file menus.c.

                                  {
    PlayerStatus* playerStatus = &gPlayerStatus;
    s32 pressedButtons;
 
    if (evt_get_variable(NULL, GB_StoryProgress) < STORY_EPILOGUE) {
        if (playerStatus->actionState != ACTION_STATE_RIDE) {
            pressedButtons = playerStatus->pressedButtons;
        } else {
            pressedButtons = gGameStatusPtr->pressedButtons[0];
        }
 
        if (!is_status_bar_visible()) {
            if (!(playerStatus->curButtons & (Z_TRIG | R_TRIG))
                && (pressedButtons & BUTTON_C_UP)
                && can_control_status_bar()
            ) {
                open_status_bar_slowly();
#if VERSION_JP
                sfx_play_sound(SOUND_LOWER_STATUS_BAR);
#else
                if (!is_picking_up_item()) {
                    sfx_play_sound(SOUND_LOWER_STATUS_BAR);
                }
#endif
            }
        } else if (!(playerStatus->curButtons & (Z_TRIG | R_TRIG))
            && (pressedButtons & BUTTON_C_UP)
            && can_control_status_bar()
        ) {
            close_status_bar();
#if VERSION_JP
            sfx_play_sound(SOUND_RAISE_STATUS_BAR);
#else
            if (!is_picking_up_item()) {
                sfx_play_sound(SOUND_RAISE_STATUS_BAR);
            }
#endif
        }
    }
}

Referenced by update_player().

◆ update_player()

void update_player ( void )

Definition at line 625 of file 77480.c.

                         {
    PlayerStatus* playerStatus = &gPlayerStatus;
    CollisionStatus* collisionStatus = &gCollisionStatus;
 
    #if DX_DEBUG_MENU
    if (dx_debug_is_cheat_enabled(DEBUG_CHEAT_SPEED_MODE)) {
        gPlayerStatus.walkSpeed = 6.0f;
        gPlayerStatus.runSpeed = 12.0f;
    }
    #endif
 
    update_partner_timers();
 
    if ((playerStatus->timeInAir > 100) || (playerStatus->pos.y < -2000.0f)) {
        if (!(playerStatus->animFlags & PA_FLAG_NO_OOB_RESPAWN)) {
            playerStatus->timeInAir = 0;
            playerStatus->pos.x = playerStatus->lastGoodPos.x;
            playerStatus->pos.y = playerStatus->lastGoodPos.y;
            playerStatus->pos.z = playerStatus->lastGoodPos.z;
 
            if (playerStatus->animFlags & PA_FLAG_RIDING_PARTNER) {
                Npc* partner;
 
                playerStatus->animFlags |= PA_FLAG_DISMOUNTING_ALLOWED | PA_FLAG_INTERRUPT_USE_PARTNER;
                partner = get_npc_unsafe(NPC_PARTNER);
                partner->pos.x = playerStatus->lastGoodPos.x;
                partner->pos.y = playerStatus->lastGoodPos.y + playerStatus->colliderHeight;
                partner->pos.z = playerStatus->lastGoodPos.z;
                partner->moveToPos.y = playerStatus->lastGoodPos.y;
            } else {
                playerStatus->timeInAir = 10;
            }
        }
    }
 
    collisionStatus->curWall = NO_COLLIDER;
    collisionStatus->lastWallHammered = NO_COLLIDER;
    collisionStatus->curInspect = NO_COLLIDER;
    collisionStatus->floorBelow = TRUE;
 
    update_player_input();
    playerStatus->flags &= ~PS_FLAG_SPECIAL_LAND;
    update_player_blink();
 
    if (playerStatus->flags & PS_FLAG_NO_STATIC_COLLISION) {
        phys_update_action_state();
        if (!check_player_action_debug()) {
            collision_main_lateral();
        }
    } else if (playerStatus->actionState != ACTION_STATE_HIT_LAVA) {
        phys_update_standard();
    } else {
        phys_update_lava_reset();
    }
 
    if (playerStatus->flags & PS_FLAG_CUTSCENE_MOVEMENT) {
        playerStatus->moveFrames--;
        if (playerStatus->moveFrames <= 0) {
            playerStatus->moveFrames = 0;
            playerStatus->flags &= ~PS_FLAG_CUTSCENE_MOVEMENT;
        }
    }
 
    if (!(playerStatus->animFlags & PA_FLAG_USING_PEACH_PHYSICS)) {
        player_surface_spawn_fx();
    }
 
    player_update_sprite();
 
    gGameStatus.playerPos.x = playerStatus->pos.x;
    gGameStatus.playerPos.y = playerStatus->pos.y;
    gGameStatus.playerPos.z = playerStatus->pos.z;
    gGameStatus.playerYaw = playerStatus->curYaw;
 
    check_input_open_menus();
    if (!(playerStatus->animFlags & PA_FLAG_USING_PEACH_PHYSICS)) {
        check_input_status_bar();
    }
 
    update_player_shadow();
 
    check_for_interactables();
    check_for_conversation_prompt();
    check_for_pulse_stone();
    check_for_ispy();
 
    playerStatus->pushVel.x = 0.0f;
    playerStatus->pushVel.y = 0.0f;
    playerStatus->pushVel.z = 0.0f;
    playerStatus->flags &= ~PS_FLAG_SLIDING;
    playerStatus->animFlags &= ~PA_FLAG_FORCE_USE_PARTNER;
}

Referenced by 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().

◆ enforce_hpfp_limits()

void enforce_hpfp_limits ( void )

Definition at line 463 of file inventory.c.

                               {
    PlayerData* playerData = &gPlayerData;
 
    playerData->curMaxHP = playerData->hardMaxHP + (is_ability_active(ABILITY_HP_PLUS) * 5);
    if (playerData->curMaxHP > 75) {
        playerData->curMaxHP = 75;
    }
    if (playerData->curHP > playerData->curMaxHP) {
        playerData->curHP = playerData->curMaxHP;
    }
 
    playerData->curMaxFP = playerData->hardMaxFP + (is_ability_active(ABILITY_FP_PLUS) * 5);
    if (playerData->curMaxFP > 75) {
        playerData->curMaxFP = 75;
    }
    if (playerData->curFP > playerData->curMaxFP) {
        playerData->curFP = playerData->curMaxFP;
    }
}

Referenced by pause_badges_handle_input(), and pause_handle_input().

◆ should_collider_allow_interact()

s32 should_collider_allow_interact ( s32 colliderID )

Returns: TRUE if colliderID is bound to an interaction trigger (press A) and the player can use it.

Definition at line 281 of file trigger.c.

                                                   {
    s32 i;
 
    if (!phys_can_player_interact()) {
        return FALSE;
    }
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentTriggerListPtr); i++) {
        Trigger* trigger = (*gCurrentTriggerListPtr)[i];
 
        if (trigger != NULL
            && trigger->hasPlayerInteractPrompt != 0
            && trigger->location.colliderID == colliderID
            && trigger->flags & TRIGGER_WALL_PRESS_A
        ) {
            return TRUE;
        }
    }
    return FALSE;
}

Referenced by check_for_interactables(), func_800E06D8(), and should_continue_inspect().

◆ show_coin_counter()

void show_coin_counter ( void )

Definition at line 1358 of file inventory.c.

                             {
    StatusBar* statusBar = &gStatusBar;
    HudElemID hid;
 
    // if a coin counter is already visible, dispose of previous counter and reset state
    if (ShowingCoinCounter || HidingCoinCounter) {
        set_window_update(WIN_CURRENCY_COUNTER, WINDOW_UPDATE_HIDE);
        if (statusBar->iconIndex12 > -1) {
            hud_element_free(statusBar->coinCountTimesHID);
            hud_element_free(statusBar->coinCountIconHID);
            statusBar->iconIndex12 = -1;
        }
        statusBar->coinCounterHideDelay = 0;
        statusBar->coinCountDisposeTime = 0;
        ShowingCoinCounter = FALSE;
        HidingCoinCounter = FALSE;
    }
 
    if (statusBar->coinCounterHideDelay == 0) {
        set_window_properties(WIN_CURRENCY_COUNTER, 32, 164, 64, 20, WINDOW_PRIORITY_21, coin_counter_draw_content, 0, -1);
        set_window_update(WIN_CURRENCY_COUNTER, (s32)basic_window_update);
        statusBar->coinCountTimesHID = hid = hud_element_create(&HES_MenuTimes);
        hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
        hud_element_set_tint(hid, 255, 255, 255);
        statusBar->coinCountIconHID = hid = hud_element_create(&HES_StatusCoin);
        hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
        hud_element_set_tint(hid, 255, 255, 255);
        statusBar->coinCounterHideDelay = 0;
 
        if (statusBar->prevIgnoreChanges < 0) {
            statusBar->prevIgnoreChanges = statusBar->ignoreChanges;
        }
 
        statusBar->ignoreChanges = TRUE;
        ShowingCoinCounter = TRUE;
    }
}

◆ hide_coin_counter_immediately()

void hide_coin_counter_immediately ( void )

Definition at line 1404 of file inventory.c.

                                         {
    StatusBar* statusBar = &gStatusBar;
 
    if (ShowingCoinCounter && (statusBar->coinCounterHideDelay == 0)) {
        statusBar->coinCounterHideDelay = 1;
    }
}

◆ hide_popup_menu()

void hide_popup_menu ( void )

Definition at line 150 of file 8a860_len_3f30.c.

                           {
    if (PopupNotBattle) {
        switch (gPopupMenu->popupType) {
            case POPUP_MENU_USE_ITEM:
            case POPUP_MENU_SWITCH_PARTNER:
            case POPUP_MENU_THROW_AWAY_ITEM:
            case POPUP_MENU_TRADE_FOR_BADGE:
            case POPUP_MENU_UPGRADE_PARTNER:
            case POPUP_MENU_SELL_ITEM:
            case POPUP_MENU_CHECK_ITEM:
            case POPUP_MENU_CLAIM_ITEM:
            case POPUP_MENU_READ_LETTER:
            case POPUP_MENU_TAKE_FROM_CHEST:
            case POPUP_MENU_USEKEY:
                set_window_update(WIN_POPUP_CONTENT, (s32) basic_hidden_window_update);
                set_window_update(WIN_POPUP_DESC, (s32) basic_hidden_window_update);
                break;
            case POPUP_MENU_READ_DIARY_PAGE:
            case POPUP_MENU_READ_POSTCARD:
            case POPUP_MENU_POST_OFFICE:
                set_window_update(WIN_POPUP_CONTENT, (s32) basic_hidden_window_update);
                break;
        }
        set_window_update(WIN_POPUP_PROMPT, WINDOW_UPDATE_HIDE);
    } else {
        switch (gPopupMenu->popupType) {
            case POPUP_MENU_USE_ITEM:
            case POPUP_MENU_SWITCH_PARTNER:
            case POPUP_MENU_THROW_AWAY_ITEM:
            case POPUP_MENU_TRADE_FOR_BADGE:
            case POPUP_MENU_UPGRADE_PARTNER:
            case POPUP_MENU_SELL_ITEM:
            case POPUP_MENU_CHECK_ITEM:
            case POPUP_MENU_CLAIM_ITEM:
            case POPUP_MENU_READ_LETTER:
            case POPUP_MENU_TAKE_FROM_CHEST:
            case POPUP_MENU_USEKEY:
                set_window_update(WIN_POPUP_CONTENT, WINDOW_UPDATE_HIDE);
                set_window_update(WIN_POPUP_DESC, WINDOW_UPDATE_HIDE);
                break;
            case POPUP_MENU_READ_DIARY_PAGE:
            case POPUP_MENU_READ_POSTCARD:
            case POPUP_MENU_POST_OFFICE:
                set_window_update(WIN_POPUP_CONTENT, WINDOW_UPDATE_HIDE);
                break;
        }
    }
 
    if (gPopupMenu->popupType == POPUP_MENU_TRADE_FOR_BADGE) {
        set_window_update(WIN_POPUP_COST, (s32) basic_hidden_window_update);
        set_window_update(WIN_CURRENCY_COUNTER, (s32) basic_hidden_window_update);
    }
    if (gPopupMenu->popupType == POPUP_MENU_UPGRADE_PARTNER) {
        set_window_update(WIN_PARTNER_COST, (s32) basic_hidden_window_update);
    }
    if (gPopupMenu->popupType == POPUP_MENU_SELL_ITEM) {
        set_window_update(WIN_POPUP_COST, (s32) basic_hidden_window_update);
        set_window_update(WIN_CURRENCY_COUNTER, (s32) basic_hidden_window_update);
    }
    gPopupState = POPUP_STATE_10;
    D_8010D644 = D_8010D692;
}

Referenced by btl_state_update_partner_menu(), btl_state_update_player_menu(), check_input_open_menus(), shop_update_item_select_popup(), and update_item_entity_pickup().

◆ destroy_popup_menu()

void destroy_popup_menu ( void )

Definition at line 213 of file 8a860_len_3f30.c.

                              {
    hud_element_free(PopupMenu_EmptybarHID);
    hud_element_free(PopupMenu_EntryIconHID);
    hud_element_free(PopupMenu_CursorHID);
    hud_element_free(PopupMenu_UpArrowHID);
    hud_element_free(PopupMenu_DownArrowHID);
 
    if (gPopupMenu->popupType == POPUP_TYPE_TRADE_FOR_BADGE) {
        hud_element_free(PopupMenu_TitleIconHID);
        hud_element_free(PopupMenu_TimesHID);
    }
 
    if (gPopupMenu->popupType == POPUP_TYPE_UPGRADE_PARTNER) {
        hud_element_free(PopupMenu_TitleIconHID);
        hud_element_free(PopupMenu_TimesHID);
    }
 
    if (gPopupMenu->popupType == POPUP_TYPE_SWITCH_PARTNER || gPopupMenu->popupType == POPUP_TYPE_UPGRADE_PARTNER) {
        hud_element_free(PopupMenu_PartnerLevelHID);
    }
 
    if (gPopupMenu->popupType == POPUP_TYPE_SELL_ITEM) {
        hud_element_free(PopupMenu_TitleIconHID);
    }
 
    if ((gPopupMenu->popupType <= POPUP_TYPE_USE_ITEM ||
         gPopupMenu->popupType == POPUP_TYPE_SWITCH_PARTNER ||
         gPopupMenu->popupType == POPUP_TYPE_THROW_AWAY_ITEM ||
         gPopupMenu->popupType == POPUP_TYPE_TRADE_FOR_BADGE ||
         gPopupMenu->popupType == POPUP_TYPE_UPGRADE_PARTNER ||
         gPopupMenu->popupType == POPUP_TYPE_USE_KEY
        ) && gGameStatusPtr->context == CONTEXT_WORLD) {
        if (!PopupMenu_WasStatusBarIgnoringChanges) {
            status_bar_respond_to_changes();
        }
        close_status_bar();
    }
 
    gPopupState = POPUP_STATE_MINUS_4;
}

Referenced by btl_state_update_partner_menu(), btl_state_update_player_menu(), check_input_open_menus(), popup_menu_update(), shop_close_item_select_popup(), and update_item_entity_pickup().

◆ reset_player_status()

void reset_player_status ( void )

Definition at line 58 of file 7B440.c.

                               {
    PlayerStatus* playerStatus = &gPlayerStatus;
    MapSettings* mapSettings;
 
    PeachDisguiseNpcIndex = -1;
    TweesterTouchingPartner = NULL;
    PulseStoneNotificationCallback = NULL;
    TalkNotificationCallback = NULL;
    InteractNotificationCallback = NULL;
    PeachDisguiseReapplyDelay = 0;
    PrevPlayerDirection = 0;
    PlayerRunStateTime = 0;
    PrevPlayerCamRelativeYaw = 0;
    D_800F7B44 = 0;
    PlayerNormalYaw = 0;
    PlayerNormalPitch = 0.0f;
    playerStatus->availableDisguiseType = 1;
    playerStatus->renderMode = RENDER_MODE_ALPHATEST;
 
    playerStatus->curAlpha = 255;
    playerStatus->prevAlpha = 255;
    gGameStatusPtr->peachFlags &= ~PEACH_FLAG_BLOCK_NEXT_DISGUISE;
    gGameStatusPtr->peachFlags &= ~PEACH_FLAG_DEPRESSED;
 
    if (gGameStatusPtr->peachFlags & PEACH_FLAG_IS_PEACH) {
        playerStatus->colliderHeight = 55;
        playerStatus->colliderDiameter = 38;
        playerStatus->animFlags |= PA_FLAG_USING_PEACH_PHYSICS;
 
        if (gGameStatusPtr->peachFlags & PEACH_FLAG_DISGUISED) {
            PeachDisguiseReapplyDelay = 2;
            playerStatus->peachDisguise = gGameStatusPtr->peachDisguise;
        }
    } else {
        playerStatus->colliderHeight = 37;
        playerStatus->colliderDiameter = 26;
        gGameStatusPtr->peachBakingIngredient = PEACH_BAKING_NONE;
    }
 
    playerStatus->walkSpeed = DefaultWalkSpeed;
    playerStatus->runSpeed = DefaultRunSpeed;
    playerStatus->maxJumpSpeed = DefaultJumpSpeed;
 
    set_action_state(ACTION_STATE_IDLE);
 
    playerStatus->curSpeed = 0.0f;
    playerStatus->targetYaw = 0.0f;
    playerStatus->overlapPushAmount = 0.0f;
    playerStatus->overlapPushYaw = 0.0f;
    playerStatus->anim = 0;
    playerStatus->timeInAir = 0;
    playerStatus->pos.x = 0.0f;
    playerStatus->pos.y = 0.0f;
    playerStatus->pos.z = 0.0f;
    playerStatus->curYaw = 0.0f;
    playerStatus->flipYaw[CAM_DEFAULT] = 0.0f;
    playerStatus->flipYaw[CAM_BATTLE] = 0.0f;
    playerStatus->flipYaw[CAM_TATTLE] = 0.0f;
    playerStatus->flipYaw[CAM_HUD] = 0.0f;
 
    ASSERT_MSG(gGameStatusPtr->areaID < ARRAY_COUNT(gAreas) - 1, "Invalid area ID %d", gGameStatusPtr->areaID);
    AreaConfig* area = &gAreas[gGameStatusPtr->areaID];
    ASSERT_MSG(gGameStatusPtr->mapID < area->mapCount, "Invalid map ID %d in %s", gGameStatusPtr->mapID, area->id);
    mapSettings = area->maps[gGameStatusPtr->mapID].settings;
 
    if (mapSettings->entryList != NULL) {
        if (gGameStatusPtr->entryID < mapSettings->entryCount) {
            playerStatus->pos.x = (*mapSettings->entryList)[gGameStatusPtr->entryID].x;
            playerStatus->pos.y = (*mapSettings->entryList)[gGameStatusPtr->entryID].y;
            playerStatus->pos.z = (*mapSettings->entryList)[gGameStatusPtr->entryID].z;
            playerStatus->curYaw = (*mapSettings->entryList)[gGameStatusPtr->entryID].yaw;
        }
    }
 
    gCameras[CAM_DEFAULT].targetPos.x = playerStatus->pos.x;
    gCameras[CAM_DEFAULT].targetPos.y = playerStatus->pos.y;
    gCameras[CAM_DEFAULT].targetPos.z = playerStatus->pos.z;
 
    phys_reset_spin_history();
    mem_clear(&gPlayerSpinState, sizeof(gPlayerSpinState));
}

Referenced by player_reset_data().

◆ player_reset_data()

void player_reset_data ( void )

Definition at line 811 of file 77480.c.

                             {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    mem_clear(playerStatus, sizeof(PlayerStatus));
    playerStatus->flags = PS_FLAG_HAS_REFLECTION;
    reset_player_status();
    playerStatus->shadowID = create_shadow_type(SHADOW_VARYING_CIRCLE, playerStatus->pos.x, playerStatus->pos.y,
                             playerStatus->pos.z);
    clear_world_menus();
    clear_interact_prompt();
    clear_conversation_prompt();
    clear_pulse_stone_icon();
    clear_ispy_icon();
    func_800E5520();
}

Referenced by load_map_by_IDs().

◆ partner_reset_data()

void partner_reset_data ( void )

Definition at line 1000 of file partners.c.

                              {
    PlayerStatus* playerStatus = &gPlayerStatus;
    s32 currentPartner = gPlayerData.curPartner;
 
    mem_clear(&gPartnerStatus, sizeof(gPartnerStatus));
    get_worker(create_worker_frontUI(_use_partner_ability, NULL));
 
    D_8010CFE0 = 1;
    NextPartnerCommand = PARTNER_CMD_RESET;
    wCurrentPartnerId = currentPartner;
 
    if (gGameStatusPtr->keepUsingPartnerOnMapChange) {
        gPartnerStatus.partnerActionState = PARTNER_ACTION_USE;
        gGameStatusPtr->keepUsingPartnerOnMapChange = FALSE;
    }
 
    wPartner = NULL;
    wSavedPartnerPosX = playerStatus->pos.x;
    wSavedPartnerPosY = playerStatus->pos.y;
    wSavedPartnerPosZ = playerStatus->pos.z;
 
    if (wCurrentPartnerId == PARTNER_NONE) {
        NextPartnerCommand = PARTNER_CMD_INIT;
    } else {
        create_partner_npc();
        wPartnerNpc->scale.x = 1.0f;
        wPartnerNpc->scale.y = 1.0f;
        wPartnerNpc->scale.z = 1.0f;
        _use_partner_ability();
    }
}

Referenced by load_map_by_IDs().

◆ has_valid_conversation_npc()

s32 has_valid_conversation_npc ( void )

Definition at line 1111 of file 77480.c.

                                     {
    PlayerStatus* playerStatus = &gPlayerStatus;
    Npc* npc = playerStatus->encounteredNPC;
    s32 ret = FALSE;
    s32 cond;
 
    if (npc != NULL && !(npc->flags & NPC_FLAG_USE_INSPECT_ICON)) {
        cond = !(playerStatus->flags & PS_FLAG_INPUT_DISABLED) && (playerStatus->flags & PS_FLAG_HAS_CONVERSATION_NPC);
        ret = cond;
    }
    return ret;
}

Referenced by check_for_conversation_prompt(), and should_continue_pulse_stone().

◆ func_800E06D8()

s32 func_800E06D8 ( void )

Definition at line 1164 of file 77480.c.

                        {
    PlayerStatus* playerStatus = &gPlayerStatus;
    s32 currentWall;
 
    if (playerStatus->timeInAir != 0 || playerStatus->inputDisabledCount != 0) {
        return FALSE;
    }
    if (gCollisionStatus.curWall == NO_COLLIDER) {
        return FALSE;
    }
    if (playerStatus->flags & PS_FLAG_HAS_CONVERSATION_NPC
        && !(playerStatus->flags & PS_FLAG_INPUT_DISABLED)
        && playerStatus->encounteredNPC != NULL
        && playerStatus->encounteredNPC->flags & NPC_FLAG_USE_INSPECT_ICON
    ) {
        playerStatus->interactingWithID = NO_COLLIDER;
        return TRUE;
    }
 
    currentWall = gCollisionStatus.curWall;
    if (!(currentWall & COLLISION_WITH_ENTITY_BIT)) {
        if (!should_collider_allow_interact(currentWall)) {
            return FALSE;
        }
    } else if (!phys_can_player_interact()) {
        playerStatus->interactingWithID = NO_COLLIDER;
        return FALSE;
    } else if (get_entity_type(currentWall) == ENTITY_TYPE_PUSH_BLOCK) {
        return FALSE;
    }
 
    if (playerStatus->interactingWithID == currentWall) {
        if (playerStatus->flags & PS_FLAG_INTERACTED) {
            return FALSE;
        }
    } else {
        playerStatus->flags &= ~PS_FLAG_INTERACTED;
    }
    playerStatus->interactingWithID = NO_COLLIDER;
 
    return TRUE;
}

Referenced by should_continue_pulse_stone().

◆ func_800E01DC()

void func_800E01DC ( void )

Definition at line 1008 of file 77480.c.

                         {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    if (playerStatus->animFlags & PA_FLAG_INTERACT_PROMPT_AVAILABLE) {
        playerStatus->flags |= PS_FLAG_INTERACTED;
    }
}

◆ collision_lateral_peach()

void collision_lateral_peach ( void )

Definition at line 1057 of file 7BB60.c.

                                   {
    PlayerStatus* playerStatus = &gPlayerStatus;
    s32 climbableStep = FALSE;
    f32 yaw = playerStatus->targetYaw;
    f32 x = playerStatus->pos.x;
    f32 y = playerStatus->pos.y;
    f32 z = playerStatus->pos.z;
    HitID wall = player_test_move_without_slipping(&gPlayerStatus, &x, &y, &z, 0, yaw, &climbableStep);
 
    playerStatus->pos.x = x;
    playerStatus->pos.z = z;
 
    // If there was a climbable step in this direction, but no wall, we can climb up it
    if (climbableStep
        && wall <= NO_COLLIDER
        && playerStatus->actionState != ACTION_STATE_STEP_UP_PEACH
        && playerStatus->curSpeed != 0.0f
    ) {
        set_action_state(ACTION_STATE_STEP_UP_PEACH);
    }
}

Referenced by collision_lava_reset_check_additional_overlaps(), and phys_update_standard().

◆ func_800E5520()

void func_800E5520 ( void )

Definition at line 36 of file 7E9D0.c.

                         {
    D_8010C9B0 = 0;
}

Referenced by player_reset_data().

◆ clear_world_menus()

void clear_world_menus ( void )

Definition at line 131 of file menus.c.

                             {
    WorldMenuState = WORLD_MENU_STATE_NONE;
}

Referenced by player_reset_data().

◆ setup_status_bar_for_battle()

void setup_status_bar_for_battle ( void )

Definition at line 1472 of file inventory.c.

                                       {
    StatusBar* statusBar = &gStatusBar;
 
    statusBar->drawPosY = 0;
    statusBar->ignoreChanges = FALSE;
    statusBar->showTimer = 210;
    statusBar->hidden = FALSE;
    statusBar->unk_3B = TRUE;
    statusBar->unk_3C = FALSE;
}

Referenced by btl_state_update_normal_start().

◆ enable_status_bar_input()

void enable_status_bar_input ( void )

Definition at line 1483 of file inventory.c.

                                   {
    gStatusBar.openInputDisabled = FALSE;
}

◆ disable_status_bar_input()

void disable_status_bar_input ( void )

Definition at line 1487 of file inventory.c.

                                    {
    gStatusBar.openInputDisabled = TRUE;
}

◆ can_control_status_bar()

b32 can_control_status_bar ( void )

Definition at line 1492 of file inventory.c.

                                 {
    if (gStatusBar.openInputDisabled) {
        return FALSE;
    }
 
    if (gStatusBar.alwaysShown) {
        return FALSE;
    }
 
    if (gStatusBar.ignoreChanges) {
        return FALSE;
    }
 
    return TRUE;
}

Referenced by check_input_status_bar().

◆ status_bar_respond_to_changes()

void status_bar_respond_to_changes ( void )

Definition at line 1519 of file inventory.c.

                                         {
    gStatusBar.ignoreChanges = FALSE;
}

Referenced by destroy_popup_menu(), shop_close_item_select_popup(), and state_step_unpause().

◆ status_bar_always_show_on()

void status_bar_always_show_on ( void )

Definition at line 1529 of file inventory.c.

                                     {
    gStatusBar.alwaysShown = TRUE;
}

Referenced by shop_open_item_select_popup().

◆ status_bar_always_show_off()

void status_bar_always_show_off ( void )

Definition at line 1533 of file inventory.c.

                                      {
    gStatusBar.alwaysShown = FALSE;
}

Referenced by draw_shop_items(), and shop_close_item_select_popup().

◆ star_power_shimmer_start()

void star_power_shimmer_start	(	s32	emitterIdx,
		f32	x,
		f32	y,
		f32	scale )

Definition at line 51 of file status_star_shimmer.c.

                                                                       {
    ShimmerEmitter* emitter = &ShimmerEmitters[emitterIdx];
    ShimmerParticle* particle = &emitter->particles[0];
    s32 numParticles = ARRAY_COUNT(emitter->particles);
    s32 j;
 
    if (emitterIdx < ARRAY_COUNT(ShimmerEmitters)) {
        particle->alive = TRUE;
        particle->pos.x = x;
        particle->pos.y = y;
        particle->scale = scale;
        particle->timeLeft = 40;
        particle->lifetime = 0;
        particle = &emitter->particles[1];
 
        for (j = 1; j < numParticles; j++, particle++) {
            particle->animTime = (s32) (-((f32) j) * 0.0f) - 1;
        }
    }
}

Referenced by update_status_bar().

◆ star_power_shimmer_init()

void star_power_shimmer_init ( void )

Definition at line 72 of file status_star_shimmer.c.

                                   {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(ShimmerEmitters); i++) {
        ShimmerEmitters[i].particles[0].alive = FALSE;
    }
}

Referenced by initialize_status_bar().

◆ star_power_shimmer_update()

void star_power_shimmer_update ( void )

Definition at line 80 of file status_star_shimmer.c.

                                     {
    ShimmerEmitter* emitter;
    ShimmerParticle* particle;
    s32 emitterTimeLeft;
    f32 emitterX;
    f32 emitterY;
    s32 i, j;
 
    for (i = 0; i < ARRAY_COUNT(ShimmerEmitters); i++, emitter++) {
        emitter = &ShimmerEmitters[i];
 
        if (!emitter->particles[0].alive) {
            continue;
        }
 
        emitter->particles[0].timeLeft--;
        emitter->particles[0].lifetime++;
 
        if (emitter->particles[0].timeLeft < 0) {
            emitter->particles[0].alive = FALSE;
            continue;
        }
 
        emitterTimeLeft = emitter->particles[0].timeLeft;
        emitterX = emitter->particles[0].pos.x;
        emitterY = emitter->particles[0].pos.y;
 
        particle = &emitter->particles[1];
        for (j = 1; j < ARRAY_COUNT(emitter->particles); j++, particle++) {
            particle->animTime++;
            if (particle->animTime >= ARRAY_COUNT(AnimatedScale)) {
                if (emitterTimeLeft < 30) {
                    particle->animTime = -31;
                } else {
                    particle->animTime = 0;
                }
            }
 
            if (particle->animTime < 0) {
                continue;
            }
 
            if (particle->animTime == 0) {
                f32 initialVelX = InitialVelocities[j - 1].x;
                f32 initialVelY = InitialVelocities[j - 1].y;
                s8 t = 127;
 
                particle->vel.x = initialVelX * 0.1;
                particle->vel.y = -initialVelY * 0.1;
                particle->pos.x = emitterX;
                particle->pos.y = emitterY;
                particle->scale = 1.0f;
                particle->rgba.r = rand_int(t);
                particle->rgba.g = rand_int(t - particle->rgba.r);
                particle->rgba.b = rand_int(t - particle->rgba.g - particle->rgba.r);
                particle->rgba.a = 255;
                particle->rgba.r += 128;
                particle->rgba.g += 128;
                particle->rgba.b += 128;
            }
 
            particle->pos.x += particle->vel.x;
            particle->pos.y += particle->vel.y;
            particle->vel.x *= 0.92;
            particle->vel.y *= 0.92;
            particle->scale = (f32) AnimatedScale[particle->animTime] * 0.04;
        }
    }
}

Referenced by update_status_bar().

◆ star_power_shimmer_draw()

void star_power_shimmer_draw ( void )

Definition at line 151 of file status_star_shimmer.c.

                                   {
    Matrix4f viewMtx, transformMtx;
    ShimmerEmitter* emitter;
    ShimmerParticle* particle;
    f32 emitterScale;
    s32 i, j;
 
    gDPPipeSync(gMainGfxPos++);
    gSPSegment(gMainGfxPos++, 0x00, 0x00000000);
    gDPSetScissor(gMainGfxPos++, G_SC_NON_INTERLACE, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
    gSPViewport(gMainGfxPos++, &ShimmerViewport);
 
    guOrthoF(viewMtx, 0.0f, SCREEN_WIDTH, SCREEN_HEIGHT, 0.0f, -100.0f, 100.0f, 1.0f);
    guMtxF2L(viewMtx, &gDisplayContext->matrixStack[gMatrixListPos]);
 
    gSPMatrix(gMainGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++], G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
    gSPDisplayList(gMainGfxPos++, D_80109710); // setup texture
    gDPSetEnvColor(gMainGfxPos++, 127, 127, 127, 127);
 
    for (i = 0; i < ARRAY_COUNT(ShimmerEmitters); i++, emitter++) {
        emitter = &ShimmerEmitters[i];
 
        if (emitter->particles[0].alive) {
            emitterScale = emitter->particles[0].scale;
 
            particle = &emitter->particles[1];
            for (j = 1; j < ARRAY_COUNT(emitter->particles); j++, particle++) {
                if (particle->animTime >= 0) {
                    guPositionF(transformMtx, 0.0f, 0.0f, gGameStatusPtr->frameCounter * 10, particle->scale * emitterScale,
                                particle->pos.x, particle->pos.y, 0.0f);
                    guMtxF2L(transformMtx, &gDisplayContext->matrixStack[gMatrixListPos]);
 
                    gSPMatrix(gMainGfxPos++, &gDisplayContext->matrixStack[gMatrixListPos++],
                              G_MTX_PUSH | G_MTX_MUL | G_MTX_MODELVIEW);
                    gDPSetPrimColor(gMainGfxPos++, 0, 80 - particle->animTime, particle->rgba.r, particle->rgba.g, particle->rgba.b, particle->rgba.a);
                    gSPDisplayList(gMainGfxPos++, D_801097D8); // draw particle
                    gSPPopMatrix(gMainGfxPos++, G_MTX_MODELVIEW);
                }
            }
        }
    }
}

Referenced by update_status_bar().

◆ shop_open_item_select_popup()

void shop_open_item_select_popup ( s32 mode )

Definition at line 382 of file shops.c.

                                           {
    PopupMenu* menu = &gGameStatusPtr->mapShop->itemSelectMenu;
    s16* itemArray;
    s32 numItemSlots;
    s32 popupType;
    s32 numEntries;
    s32 i;
 
    switch (mode) {
        case ITEM_POPUP_SELL:
            popupType = POPUP_MENU_SELL_ITEM;
            numItemSlots = ARRAY_COUNT(gPlayerData.invItems);
            itemArray = gPlayerData.invItems;
            break;
        case ITEM_POPUP_CHECK:
            popupType = POPUP_MENU_CHECK_ITEM;
            numItemSlots = ARRAY_COUNT(gPlayerData.invItems);
            itemArray = gPlayerData.invItems;
            break;
        case ITEM_POPUP_CLAIM:
        default:
            popupType = POPUP_MENU_CLAIM_ITEM;
            numItemSlots = ARRAY_COUNT(gPlayerData.storedItems);
            itemArray = gPlayerData.storedItems;
            break;
    }
 
    numEntries = 0;
 
    for (i = 0; i < numItemSlots; i++) {
        s32 itemID = itemArray[i];
        if (itemID == ITEM_NONE) {
            continue;
        }
        ItemData* itemData = &gItemTable[itemID];
 
        menu->ptrIcon[numEntries] = gItemHudScripts[itemData->hudElemID].enabled;
        menu->userIndex[numEntries] = i;
        menu->enabled[numEntries] = TRUE;
        menu->nameMsg[numEntries] = itemData->nameMsg;
        menu->descMsg[numEntries] = itemData->shortDescMsg;
        menu->value[numEntries] = shop_get_sell_price(itemID);
        numEntries++;
    }
 
    menu->popupType = popupType;
    menu->numEntries = numEntries;
    menu->initialPos = 0;
    create_shop_popup_menu(menu);
    status_bar_ignore_changes();
    status_bar_always_show_on();
    open_status_bar_quickly();
}

◆ hide_coin_counter()

void hide_coin_counter ( void )

Definition at line 1396 of file inventory.c.

                             {
    StatusBar* statusBar = &gStatusBar;
 
    if (ShowingCoinCounter && (statusBar->coinCounterHideDelay == 0)) {
        statusBar->coinCounterHideDelay = 60;
    }
}

◆ set_message_text_var()

void set_message_text_var	(	s32	msgID,
		s32	index )

Definition at line 1520 of file msg.c.

                                                {
    u8* mallocSpace = NULL;
    s32 i;
    u8* msgVars;
 
    if (msgID >= 0) {
        mallocSpace = general_heap_malloc(0x400);
        dma_load_msg(msgID, mallocSpace);
        msgID = (s32)mallocSpace;
    }
 
    i = 0;
    msgVars = gMessageMsgVars[index];
    while (TRUE) {
        msgVars[i] = ((u8*)msgID)[i];
        if (((u8*)msgID)[i] == MSG_CHAR_READ_END) {
            break;
        }
 
        if (++i >= 32) {
            msgVars[i - 1] = MSG_CHAR_READ_END;
            break;
        }
    }
 
    if (mallocSpace != NULL) {
        general_heap_free(mallocSpace);
    }
}

Referenced by btl_message_popup_draw_content(), btl_show_message_popup(), draw_content_pickup_item_header(), func_801363A0(), shop_owner_buy_dialog(), and shop_owner_continue_speech_with_quantity().

◆ set_message_int_var()

void set_message_int_var	(	s32	value,
		s32	index )

Definition at line 1550 of file msg.c.

                                               {
    s8 strBuffer[ARRAY_COUNT(gMessageMsgVars[index])];
    s8* bufferIt;
    s32 i;
 
    int_to_string(value, strBuffer, 10);
 
    for (i = 0, bufferIt = strBuffer; i < ARRAY_COUNT(gMessageMsgVars[index]) - 1; i++) {
        s8 thisChar = bufferIt[i];
 
        if (thisChar == 0) {
            break;
        }
        gMessageMsgVars[index][i] = thisChar - '0' + MSG_CHAR_DIGIT_0;
    }
    gMessageMsgVars[index][i] = MSG_CHAR_READ_END;
}

Referenced by btl_message_popup_draw_content(), btl_show_message_popup(), popup_menu_draw_menu_contents(), shop_owner_buy_dialog(), and shop_owner_continue_speech_with_quantity().

◆ open_status_bar_quickly()

void open_status_bar_quickly ( void )

Definition at line 1441 of file inventory.c.

                                   {
    StatusBar* statusBar = &gStatusBar;
 
    if (statusBar->hidden) {
        statusBar->showTimer = 105;
        statusBar->hidden = FALSE;
        statusBar->unk_3B = TRUE;
    }
}

Referenced by create_standard_popup_menu(), and shop_open_item_select_popup().

◆ show_immune_bonk()

void show_immune_bonk	(	f32	x,
		f32	y,
		f32	z,
		s32	numStars,
		s32	startupTime,
		s32	animDir )

Definition at line 349 of file popup_messages.c.

                                                                                       {
    BattleStatus* battleStatus = &gBattleStatus;
    PopupMessage* popup;
    BonkData* bonkData;
    f32 timescale;
    f32 baseScale;
    s32 bonkPosIdx;
    b32 hasShortLifetime;
    s32 sign;
    s32 i;
 
    popup = btl_create_popup();
    if (popup == NULL) {
        // unable to create popup
        return;
    }
 
    if (numStars < 1) {
        numStars = 1;
        baseScale = 0.4f;
        timescale = 0.7f;
        hasShortLifetime = TRUE;
    } else {
        baseScale = 1.0f;
        timescale = 1.0f;
        hasShortLifetime = FALSE;
    }
 
    if (battleStatus->flags1 & (BS_FLAGS1_NICE_HIT | BS_FLAGS1_SUPER_HIT)) {
        baseScale *= 2.0;
    }
 
    if (animDir < 0) {
        sign = -1;
    } else {
        sign = 1;
    }
 
    animDir = abs(animDir) % 5;
 
    battleStatus->unk_90 = 0;
    popup->updateFunc = btl_bonk_update;
    popup->renderWorldFunc = btl_bonk_render;
    popup->unk_00 = FALSE;
    popup->renderUIFunc = NULL;
    popup->messageIndex = 1;
    popup->active |= 0x10;
    bonkData = popup->data.bonk = heap_malloc(numStars * sizeof(*popup->data.bonk));
    ASSERT (popup->data.bonk != NULL);
 
    for (i = 0; i < numStars; i++) {
        bonkData->alive = TRUE;
        bonkData->entityModelIndex = load_entity_model(BonkModelScripts[numStars]);
        set_entity_model_flags(bonkData->entityModelIndex, ENTITY_MODEL_FLAG_HIDDEN);
        bind_entity_model_setupGfx(bonkData->entityModelIndex, bonkData, btl_bonk_setup_gfx);
        bonkData->pos.x = x;
        bonkData->pos.y = y;
        bonkData->pos.z = z;
        bonkPosIdx = animDir % 8;
        animDir++;
 
        bonkData->accel.x = BonkAnimAccel[bonkPosIdx].x * timescale * sign ;
        bonkData->accel.y = BonkAnimAccel[bonkPosIdx].y * timescale;
        bonkData->accel.z = BonkAnimAccel[bonkPosIdx].z * timescale;
        bonkData->vel.x = 2.0 * bonkData->accel.x;
        bonkData->vel.y = 2.0 * bonkData->accel.y;
        bonkData->vel.z = 2.0 * bonkData->accel.z;
 
        bonkData->scale = BonkAnimScale[i % 8].x * baseScale;
        bonkData->rotY = clamp_angle(180.0f - gCameras[CAM_BATTLE].curYaw);
        bonkData->rotZ = 0;
        bonkData->rotVelZ = sign * 107;
 
        bonkData->startupTime = startupTime;
        bonkData->moveTime = 14;
        bonkData->holdTime = 240;
        if (hasShortLifetime) {
            bonkData->holdTime = 10;
        }
 
        bonkData->alpha = 255.0f;
        bonkData++;
    }
}

Referenced by calc_enemy_damage_target(), calc_item_damage_enemy(), calc_partner_damage_enemy(), and calc_player_damage_enemy().

◆ show_primary_damage_popup()

void show_primary_damage_popup	(	f32	x,
		f32	y,
		f32	z,
		s32	attack,
		s32	a )

Definition at line 2269 of file 190B20.c.

                                                                                       {
    s32 i;
 
    for (i = 0; i < 1; i++) {
        if (gDamageCountEffects[i] == NULL) {
            break;
        }
    }
 
    if (i > 0) {
        i = 0;
        gDamageCountEffects[i]->data.damageIndicator->timeLeft = 5;
        gDamageCountEffects[i] = NULL;
    }
 
    if (angle == 0) {
        angle = -55;
    } else {
        angle = 55;
    }
 
    fx_damage_indicator(0, posX, posY, posZ, 10.0f, angle, damageAmt, &gDamageCountEffects[i]);
    gDamageCountTimers[i] = 40;
}

Referenced by calc_enemy_damage_target(), calc_item_damage_enemy(), calc_partner_damage_enemy(), and calc_player_damage_enemy().

◆ dispatch_damage_event_partner()

s32 dispatch_damage_event_partner	(	s32	damageAmount,
		s32	event,
		s32	stopMotion )

Definition at line 909 of file dmg_partner.c.

                                                                               {
    BattleStatus* battleStatus = &gBattleStatus;
    Actor* partner = battleStatus->partnerActor;
    ActorState* state = &partner->state;
    s32 hpChange;
    s32 flagCheck;
 
    battleStatus->curAttackDamage = damageAmount;
 
    hpChange = (s16)damageAmount;
    partner->hpChangeCounter += hpChange;
 
    hpChange = partner->hpChangeCounter;
    partner->curHP = 127;
    partner->damageCounter += hpChange;
    partner->hpChangeCounter -= hpChange;
    battleStatus->lastAttackDamage = 0;
    partner->curHP -= hpChange;
 
    if (partner->curHP <= 0) {
        event = EVENT_DEATH;
        battleStatus->lastAttackDamage += partner->curHP;
        partner->curHP = 0;
    }
 
    battleStatus->lastAttackDamage += hpChange;
    partner->lastDamageTaken = battleStatus->lastAttackDamage;
    battleStatus->curDamageSource = DMG_SRC_DEFAULT;
    if (gBattleStatus.flags1 & BS_FLAGS1_TRIGGER_EVENTS) {
        if (event == EVENT_HIT_COMBO) {
            event = EVENT_HIT;
        }
        if (event == EVENT_ZERO_DAMAGE) {
            event = EVENT_IMMUNE;
        }
    }
 
    if (battleStatus->lastAttackDamage > 0) {
        gBattleStatus.flags1 |= BS_FLAGS1_TRIGGER_EVENTS;
 
        inflict_status(partner, STATUS_KEY_DAZE, battleStatus->lastAttackDamage);
    }
 
    if (!stopMotion) {
        set_goal_pos_to_part(state, ACTOR_PARTNER, 0);
    }
 
    show_next_damage_popup(state->goalPos.x, state->goalPos.y, state->goalPos.z,
                      battleStatus->lastAttackDamage, 1);
    show_damage_fx(partner, state->goalPos.x, state->goalPos.y, state->goalPos.z,
                  battleStatus->lastAttackDamage);
 
    if (battleStatus->lastAttackDamage > 0) {
        set_actor_flash_mode(partner, 1);
    }
 
    partner->flags |= ACTOR_FLAG_HEALTH_BAR_HIDDEN;
 
    flagCheck = (gBattleStatus.flags1 & (BS_FLAGS1_NICE_HIT | BS_FLAGS1_SUPER_HIT)) != 0;
    dispatch_event_partner(event);
    return flagCheck;
}

Referenced by dispatch_damage_event_partner_0(), and dispatch_damage_event_partner_1().

◆ disable_actor_blur()

void disable_actor_blur ( Actor * actor )

Definition at line 223 of file actor_rendering.c.

                                      {
    ActorPart* actorPart = actor->partsTable;
 
    if ((actorPart->idleAnimations != NULL) && !(actorPart->flags & ACTOR_PART_FLAG_NO_DECORATIONS)) {
        DecorationTable* decorations = actorPart->decorationTable;
 
        if (decorations->blurEnableCount != 0) {
            decorations->blurEnableCount--;
            if (decorations->blurEnableCount == 0) {
                decorations->blurDisableDelay = 20;
            }
        }
    }
}

Referenced by disable_partner_blur().

◆ reset_actor_blur()

void reset_actor_blur ( Actor * actor )

Definition at line 238 of file actor_rendering.c.

                                    {
    ActorPart* actorPart = actor->partsTable;
 
    if ((actorPart->idleAnimations != NULL) && !(actorPart->flags & ACTOR_PART_FLAG_NO_DECORATIONS)) {
        DecorationTable* decorations = actorPart->decorationTable;
 
        if (decorations->blurEnableCount != 0) {
            decorations->blurEnableCount--;
            if (decorations->blurEnableCount == 0) {
                actor->flags &= ~ACTOR_FLAG_BLUR_ENABLED;
                decorations->blurDisableDelay = 1;
            }
        }
    }
}

Referenced by reset_partner_blur().

◆ enable_actor_blur()

void enable_actor_blur ( Actor * actor )

Definition at line 189 of file actor_rendering.c.

                                     {
    ActorPart* partsTable = actor->partsTable;
    DecorationTable* decorations = partsTable->decorationTable;
    s32 i, j;
    s32 numParts;
 
    decorations->blurDisableDelay = 0;
    decorations->blurEnableCount++;
    actor->flags |= ACTOR_FLAG_BLUR_ENABLED;
    partsTable = actor->partsTable;
    numParts = actor->numParts;
 
    for (i = 0; i < numParts; i++) {
        if (partsTable->idleAnimations != NULL && !(partsTable->flags & ACTOR_PART_FLAG_NO_DECORATIONS)) {
            decorations = partsTable->decorationTable;
            decorations->blurUnused = 0;
            decorations->blurBufferPos = 0;
            for (j = 0; j < ARRAY_COUNT(decorations->posX); j++) {
                decorations->posX[j] = partsTable->curPos.x;
                decorations->posY[j] = partsTable->curPos.y;
                decorations->posZ[j] = partsTable->curPos.z;
                decorations->yaw[j] = actor->yaw;
                decorations->rotPivotOffsetX[j] = (s32)(actor->rotPivotOffset.x * actor->scalingFactor);
                decorations->rotPivotOffsetY[j] = (s32)(actor->rotPivotOffset.y * actor->scalingFactor);
 
                decorations->rotX[j] = clamp_angle(actor->rot.x) * 0.5f;
                decorations->rotY[j] = clamp_angle(actor->rot.y) * 0.5f;
                decorations->rotZ[j] = clamp_angle(actor->rot.z) * 0.5f;
            }
        }
        partsTable = partsTable->nextPart;
    }
}

Referenced by enable_partner_blur().

◆ apply_shock_effect()

void apply_shock_effect ( Actor * actor )

Definition at line 2060 of file popup_messages.c.

                                      {
    ActorPart* part = actor->partsTable;
 
    while (part != NULL) {
        if (!(part->flags & ACTOR_PART_FLAG_INVISIBLE)
            && part->idleAnimations != NULL
            && !(part->flags & ACTOR_PART_FLAG_SKIP_SHOCK_EFFECT)
        ) {
            f32 x = part->curPos.x;
            f32 y = part->curPos.y + (actor->size.y / 10);
            f32 z = part->curPos.z;
            s32 f1 = (part->size.x + (part->size.x / 4)) * actor->scalingFactor;
            s32 f2 = (part->size.y - 2) * actor->scalingFactor;
 
            if (actor->flags & ACTOR_FLAG_HALF_HEIGHT) {
                y -= actor->size.y / 2;
            }
 
            fx_flashing_box_shockwave(0, x, y, z, f1, f2);
        }
        part = part->nextPart;
    }
}

Referenced by calc_enemy_damage_target(), calc_item_damage_enemy(), calc_partner_damage_enemy(), calc_partner_test_enemy(), calc_player_damage_enemy(), and show_damage_fx().

◆ part_glow_off()

void part_glow_off	(	s32	isNpcSprite,
		ActorPart *	part,
		s32	yaw,
		b32	arg3 )

Definition at line 3348 of file actor_rendering.c.

                                                                                {
    if (part->decorationTable->glowStateChanged) {
        part->decorationTable->glowStateChanged = FALSE;
        if (isNpcSprite == SPRITE_MODE_PLAYER) {
            set_player_imgfx_all(PLAYER_SPRITE_MAIN, IMGFX_CLEAR, 0, 0, 0, 0, 0);
        } else {
            set_npc_imgfx_all(part->spriteInstanceID, IMGFX_CLEAR, 0, 0, 0, 0, 0);
        }
    }
}

Referenced by update_part_glow().

◆ part_flash_off()

void part_flash_off	(	b32	isNpcSprite,
		ActorPart *	part,
		s32	yaw,
		b32	isReflection )

Definition at line 3428 of file actor_rendering.c.

                                                                                 {
    DecorationTable* decorations = part->decorationTable;
 
    if (decorations->flashStateChanged) {
        decorations->flashStateChanged = FALSE;
    }
    decorations->flashEnabled = FLASH_PAL_OFF;
}

Referenced by update_part_flash().

◆ part_flash_on()

void part_flash_on	(	b32	isNpcSprite,
		ActorPart *	part,
		s32	yaw,
		b32	isReflection )

Definition at line 3437 of file actor_rendering.c.

                                                                                {
    DecorationTable* decorations = part->decorationTable;
 
    if (decorations->flashStateChanged) {
        switch (get_flash_damage_intensity(part)) {
            case DAMAGE_INTENSITY_LIGHT:
                decorations->flashFramesLeft = 1;
                decorations->flashMode = FLASH_MODE_LIGHT;
                break;
            case DAMAGE_INTENSITY_MEDIUM:
                decorations->flashFramesLeft = 8;
                decorations->flashMode = FLASH_MODE_MEDIUM;
                break;
            case DAMAGE_INTENSITY_HEAVY:
            default:
                decorations->flashFramesLeft = 14;
                decorations->flashMode = FLASH_MODE_HEAVY;
                break;
        }
        decorations->flashEnabled = FLASH_PAL_OFF;
        decorations->flashStateChanged = FALSE;
    }
 
    if (decorations->flashMode == FLASH_MODE_DISPOSE) {
        decorations->flashEnabled = FLASH_PAL_OFF;
        clear_part_flash_mode(part);
    }
 
    switch (decorations->flashMode) {
        case FLASH_MODE_LIGHT:
            switch (decorations->flashFramesLeft) {
                case 0:
                    decorations->flashEnabled = FLASH_PAL_ON;
                    decorations->flashMode = FLASH_MODE_DISPOSE;
                    break;
                default:
                    decorations->flashEnabled = FLASH_PAL_OFF;
                    if (!isReflection) {
                        decorations->flashFramesLeft--;
                    }
                    break;
            }
            break;
        case FLASH_MODE_MEDIUM:
           switch (decorations->flashFramesLeft) {
                case 1:
                case 2:
                case 5:
                case 6:
                    decorations->flashEnabled = FLASH_PAL_ON;
                    break;
                case 3:
                case 4:
                case 7:
                case 8:
                    decorations->flashEnabled = FLASH_PAL_OFF;
                    break;
                case 0:
                    decorations->flashMode = FLASH_MODE_DISPOSE;
                    break;
            }
            if (!isReflection) {
                decorations->flashFramesLeft--;
            }
            break;
        case FLASH_MODE_HEAVY:
           switch (decorations->flashFramesLeft) {
                case 1:
                case 2:
                case 5:
                case 6:
                case 9:
                case 10:
                case 13:
                case 14:
                    decorations->flashEnabled = FLASH_PAL_OFF;
                    break;
                case 3:
                case 4:
                case 7:
                case 8:
                case 11:
                case 12:
                    decorations->flashEnabled = FLASH_PAL_ON;
                    break;
                case 0:
                    decorations->flashMode = FLASH_MODE_DISPOSE;
                    break;
            }
            if (!isReflection) {
                decorations->flashFramesLeft--;
            }
            break;
    }
}

Referenced by update_part_flash().

◆ _add_part_decoration()

void _add_part_decoration ( ActorPart * actorPart )

Definition at line 3533 of file actor_rendering.c.

                                                {
    DecorationTable* decorations;
    s32 i;
 
    if (actorPart->flags & ACTOR_PART_FLAG_NO_DECORATIONS) {
        return;
    }
 
    decorations = actorPart->decorationTable;
    for (i = 0; i < ARRAY_COUNT(decorations->type); i++) {
        switch (decorations->type[i]) {
            case ACTOR_DECORATION_NONE:
                add_part_decor_none(actorPart, i);
                break;
            case ACTOR_DECORATION_GOLDEN_FLAMES:
                add_part_decor_golden_flames(actorPart, i);
                break;
            case ACTOR_DECORATION_SWEAT:
                add_part_decor_sweat(actorPart, i);
                break;
            case ACTOR_DECORATION_SEEING_STARS:
                add_part_decor_seeing_stars(actorPart, i);
                break;
            case ACTOR_DECORATION_RED_FLAMES:
                add_part_decor_red_flames(actorPart, i);
                break;
            case ACTOR_DECORATION_GREY_SMOKE_TRAIL:
                add_part_decor_smoky_trail(actorPart, i);
                break;
            case ACTOR_DECORATION_FIRE_SMOKE_TRAIL:
                add_part_decor_fiery_trail(actorPart, i);
                break;
            case ACTOR_DECORATION_WHIRLWIND:
                add_part_decor_whirlwind(actorPart, i);
                break;
            case ACTOR_DECORATION_STEAM_EMITTER:
                add_part_decor_steam(actorPart, i);
                break;
            case ACTOR_DECORATION_SPARKLES:
                add_part_decor_sparkles(actorPart, i);
                break;
            case ACTOR_DECORATION_BOWSER_AURA:
                add_part_decor_bowser_aura(actorPart, i);
                break;
            case ACTOR_DECORATION_RADIAL_STAR_EMITTER:
                add_part_decor_radiating_stars(actorPart, i);
                break;
        }
    }
}

Referenced by add_part_decoration(), appendGfx_npc_actor(), and appendGfx_player_actor().

◆ _remove_part_decoration()

void _remove_part_decoration	(	ActorPart *	part,
		s32	decorationIndex )

Definition at line 3584 of file actor_rendering.c.

                                                       {
    DecorationTable* decorations = part->decorationTable;
 
    switch (decorations->type[idx]) {
        case ACTOR_DECORATION_NONE:
            remove_part_decor_none(part, idx);
            break;
        case ACTOR_DECORATION_GOLDEN_FLAMES:
            remove_part_decor_golden_flames(part, idx);
            break;
        case ACTOR_DECORATION_SWEAT:
            remove_part_decor_sweat(part, idx);
            break;
        case ACTOR_DECORATION_SEEING_STARS:
            remove_part_decor_seeing_stars(part, idx);
            break;
        case ACTOR_DECORATION_RED_FLAMES:
            remove_part_decor_red_flames(part, idx);
            break;
        case ACTOR_DECORATION_GREY_SMOKE_TRAIL:
            remove_part_decor_smoky_trail(part, idx);
            break;
        case ACTOR_DECORATION_FIRE_SMOKE_TRAIL:
            remove_part_decor_fiery_trail(part, idx);
            break;
        case ACTOR_DECORATION_WHIRLWIND:
            remove_part_decor_whirlwind(part, idx);
            break;
        case ACTOR_DECORATION_STEAM_EMITTER:
            remove_part_decor_steam(part, idx);
            break;
        case ACTOR_DECORATION_SPARKLES:
            remove_part_decor_sparkles(part, idx);
            break;
        case ACTOR_DECORATION_BOWSER_AURA:
            remove_part_decor_bowser_aura(part, idx);
            break;
        case ACTOR_DECORATION_RADIAL_STAR_EMITTER:
            remove_part_decor_radiating_stars(part, idx);
            break;
    }
 
    decorations->type[idx] = ACTOR_DECORATION_NONE;
}

Referenced by add_part_decoration(), and remove_part_decoration().

◆ remove_part_decor_none()

void remove_part_decor_none	(	ActorPart *	part,
		s32	idx )

Definition at line 3632 of file actor_rendering.c.

3632 {

3633}

Referenced by _remove_part_decoration().

◆ remove_part_decor_golden_flames()

void remove_part_decor_golden_flames	(	ActorPart *	part,
		s32	idx )

Definition at line 3665 of file actor_rendering.c.

                                                               {
    part->decorationTable->effect[idx]->data.aura->fadeTime = 5;
}

Referenced by _remove_part_decoration().

◆ remove_part_decor_sweat()

void remove_part_decor_sweat	(	ActorPart *	part,
		s32	idx )

Definition at line 3692 of file actor_rendering.c.

3692 {

3693}

Referenced by _remove_part_decoration().

◆ remove_part_decor_seeing_stars()

void remove_part_decor_seeing_stars	(	ActorPart *	part,
		s32	idx )

Definition at line 3714 of file actor_rendering.c.

                                                              {
    remove_effect(part->decorationTable->effect[idx]);
}

Referenced by _remove_part_decoration().

◆ remove_part_decor_red_flames()

void remove_part_decor_red_flames	(	ActorPart *	part,
		s32	idx )

Definition at line 3754 of file actor_rendering.c.

                                                            {
    part->decorationTable->effect[idx]->data.aura->fadeTime = 5;
}

Referenced by _remove_part_decoration().

◆ remove_part_decor_smoky_trail()

void remove_part_decor_smoky_trail	(	ActorPart *	part,
		s32	idx )

Definition at line 3776 of file actor_rendering.c.

                                                             {
    part->decorationTable->effect[idx]->flags |= FX_INSTANCE_FLAG_DISMISS;
}

Referenced by _remove_part_decoration().

◆ remove_part_decor_fiery_trail()

void remove_part_decor_fiery_trail	(	ActorPart *	part,
		s32	idx )

Definition at line 3800 of file actor_rendering.c.

                                                             {
    part->decorationTable->effect[idx]->flags |= FX_INSTANCE_FLAG_DISMISS;
}

Referenced by _remove_part_decoration().

◆ remove_part_decor_whirlwind()

void remove_part_decor_whirlwind	(	ActorPart *	part,
		s32	idx )

Definition at line 3822 of file actor_rendering.c.

                                                           {
    part->decorationTable->effect[idx]->flags |= FX_INSTANCE_FLAG_DISMISS;
}

Referenced by _remove_part_decoration().

◆ remove_part_decor_steam()

void remove_part_decor_steam	(	ActorPart *	part,
		s32	idx )

Definition at line 3852 of file actor_rendering.c.

3852 {

3853}

Referenced by _remove_part_decoration().

◆ remove_part_decor_sparkles()

void remove_part_decor_sparkles	(	ActorPart *	part,
		s32	idx )

Definition at line 3882 of file actor_rendering.c.

3882 {

3883}

Referenced by _remove_part_decoration().

◆ remove_part_decor_bowser_aura()

void remove_part_decor_bowser_aura	(	ActorPart *	part,
		s32	idx )

Definition at line 3919 of file actor_rendering.c.

                                                             {
    part->decorationTable->effect[idx]->data.aura->fadeTime = 5;
}

Referenced by _remove_part_decoration().

◆ remove_part_decor_radiating_stars()

void remove_part_decor_radiating_stars	(	ActorPart *	part,
		s32	idx )

Definition at line 3947 of file actor_rendering.c.

                                                                 {
    part->decorationTable->effect[idx]->flags |= FX_INSTANCE_FLAG_DISMISS;
}

Referenced by _remove_part_decoration().

◆ status_bar_ignore_changes()

void status_bar_ignore_changes ( void )

Definition at line 1508 of file inventory.c.

                                     {
    gStatusBar.ignoreChanges = TRUE;
}

Referenced by create_standard_popup_menu(), and shop_open_item_select_popup().

◆ imgfx_release_instance()

void imgfx_release_instance ( u32 idx )

Definition at line 385 of file imgfx.c.

                                     {
    if (idx < MAX_IMGFX_INSTANCES) {
        (*ImgFXInstances)[idx].flags = 0;
        (*ImgFXInstances)[idx].nextIdx = -1;
    }
}

Referenced by hud_element_free_transform(), imgfx_release_instance_chain(), and spr_free_sprite().

◆ set_script_flags()

void set_script_flags	(	Evt *	script,
		s32	flags )

Definition at line 913 of file script_list.c.

                                              {
    Evt* childScript = script->childScript;
    s32 i;
 
    script->stateFlags |= flags;
    if (childScript != NULL) {
        set_script_flags(childScript, flags);
    }
 
    for (i = 0; i < MAX_SCRIPTS; i++) {
        Evt* scriptContextPtr = (*gCurrentScriptListPtr)[i];
 
        if (scriptContextPtr != NULL && scriptContextPtr->parentScript == script) {
            set_script_flags(script->parentScript, flags);
        }
    }
}

Referenced by set_script_flags(), and update_encounters_neutral().

◆ clear_script_flags()

void clear_script_flags	(	Evt *	script,
		s32	flags )

Definition at line 931 of file script_list.c.

                                                {
    Evt* childScript = script->childScript;
    s32 i;
 
    script->stateFlags &= ~flags;
    if (childScript != NULL) {
        clear_script_flags(childScript, flags);
    }
 
    for (i = 0; i < MAX_SCRIPTS; i++) {
        Evt* scriptContextPtr = (*gCurrentScriptListPtr)[i];
 
        if (scriptContextPtr != NULL && scriptContextPtr->parentScript == script) {
            clear_script_flags(scriptContextPtr, flags);
        }
    }
}

Referenced by clear_script_flags(), and update_encounters_neutral().

◆ disable_player_blur()

void disable_player_blur ( void )

Definition at line 307 of file actor_rendering.c.

                               {
    Actor* playerActor = gBattleStatus.playerActor;
    ActorPart* partsTable = playerActor->partsTable;
    DecorationTable* decorations = partsTable->decorationTable;
 
    if (decorations->blurEnableCount != 0) {
        decorations->blurEnableCount--;
        if (decorations->blurEnableCount == 0) {
            decorations->blurDisableDelay = 20;
        }
    }
}

◆ enable_player_blur()

void enable_player_blur ( void )

Definition at line 281 of file actor_rendering.c.

                              {
    Actor* playerActor = gBattleStatus.playerActor;
    ActorPart* partsTable = playerActor->partsTable;
    DecorationTable* decorations = partsTable->decorationTable;
    s32 i;
 
    decorations->blurDisableDelay = 0;
    decorations->blurEnableCount++;
    playerActor->flags |= ACTOR_FLAG_BLUR_ENABLED;
    decorations->blurUnused = 0;
    decorations->blurBufferPos = 0;
 
    for (i = 0; i < ARRAY_COUNT(decorations->posX); i++) {
        decorations->posX[i] = partsTable->curPos.x;
        decorations->posY[i] = partsTable->curPos.y;
        decorations->posZ[i] = partsTable->curPos.z;
        decorations->yaw[i] = playerActor->yaw;
        decorations->rotPivotOffsetX[i] = playerActor->rotPivotOffset.x * playerActor->scalingFactor;
        decorations->rotPivotOffsetY[i] = playerActor->rotPivotOffset.y * playerActor->scalingFactor;
 
        decorations->rotX[i] = clamp_angle(playerActor->rot.x) * 0.5f;
        decorations->rotY[i] = clamp_angle(playerActor->rot.y) * 0.5f;
        decorations->rotZ[i] = clamp_angle(playerActor->rot.z) * 0.5f;
    }
}

◆ reset_player_blur()

void reset_player_blur ( void )

Definition at line 320 of file actor_rendering.c.

                             {
    Actor* playerActor = gBattleStatus.playerActor;
    ActorPart* partsTable = playerActor->partsTable;
    DecorationTable* decorations = partsTable->decorationTable;
 
    if (decorations->blurEnableCount != 0) {
        decorations->blurEnableCount--;
        if (decorations->blurEnableCount == 0) {
            playerActor->flags &= ~ACTOR_FLAG_BLUR_ENABLED;
            decorations->blurDisableDelay = 1;
        }
    }
}

◆ force_disable_player_blur()

void force_disable_player_blur ( void )

Definition at line 334 of file actor_rendering.c.

                                     {
    Actor* playerActor = gBattleStatus.playerActor;
    ActorPart* partsTable = playerActor->partsTable;
    DecorationTable* decorations = partsTable->decorationTable;
 
    decorations->blurEnableCount = 0;
    decorations->blurDisableDelay = 20;
}

◆ force_disable_player_blur_immediately()

void force_disable_player_blur_immediately ( void )

Definition at line 343 of file actor_rendering.c.

                                                 {
    Actor* playerActor = gBattleStatus.playerActor;
    ActorPart* partsTable = playerActor->partsTable;
    DecorationTable* decorations = partsTable->decorationTable;
 
    playerActor->flags &= ~ACTOR_FLAG_BLUR_ENABLED;
    decorations->blurEnableCount = 0;
    decorations->blurDisableDelay = 1;
}

◆ func_8023E104()

void func_8023E104 ( void )

Definition at line 150 of file 16C8E0.c.

                         {
    D_802809F4 = 1;
    D_802809F5 = 0;
}

Referenced by btl_state_update_run_away().

◆ func_8023E11C()

void func_8023E11C ( void )

Definition at line 155 of file 16C8E0.c.

                         {
    D_802809F4 = 0;
    D_802809F5 = 0;
}

Referenced by btl_state_update_run_away().

◆ set_goal_pos_to_part()

void set_goal_pos_to_part	(	ActorState *	state,
		s32	actorID,
		s32	partID )

Definition at line 44 of file actor_api.c.

                                                                      {
    s32 actorClass = actorID & ACTOR_CLASS_MASK;
    Actor* actor = get_actor(actorID);
    ActorPart* part;
 
    switch (actorClass) {
        case ACTOR_CLASS_PLAYER:
            part = get_actor_part(actor, 0);
            state->goalPos.x = actor->curPos.x + part->partOffset.x * actor->scalingFactor;
            state->goalPos.y = actor->curPos.y + part->partOffset.y * actor->scalingFactor;
            state->goalPos.z = actor->curPos.z + 10.0f;
            if (actor->stoneStatus == STATUS_KEY_STONE) {
                state->goalPos.y -= actor->scalingFactor * 5.0f;
            }
            break;
        case ACTOR_CLASS_PARTNER:
        case ACTOR_CLASS_ENEMY:
            part = get_actor_part(actor, partID);
            if (!(part->flags & ACTOR_PART_FLAG_USE_ABSOLUTE_POSITION)) {
                state->goalPos.x = actor->curPos.x + (part->partOffset.x + part->targetOffset.x) * actor->scalingFactor;
                if (!(actor->flags & ACTOR_FLAG_UPSIDE_DOWN)) {
                    state->goalPos.y = actor->curPos.y + (part->partOffset.y + part->targetOffset.y) * actor->scalingFactor;
                } else {
                    state->goalPos.y = actor->curPos.y + (-part->partOffset.y - part->targetOffset.y) * actor->scalingFactor;
                }
                state->goalPos.z = actor->curPos.z + part->partOffset.z + 10.0f;
            } else {
                state->goalPos.x = part->absolutePos.x + part->targetOffset.x;
                if (!(actor->flags & ACTOR_FLAG_UPSIDE_DOWN)) {
                    state->goalPos.y = part->absolutePos.y + part->targetOffset.y * actor->scalingFactor;
                } else {
                    state->goalPos.y = part->absolutePos.y - part->targetOffset.y * actor->scalingFactor;
                }
                state->goalPos.z = part->absolutePos.z + 10.0f;
            }
            break;
    }
}

Referenced by dispatch_damage_event_partner(), and dispatch_damage_event_player().

◆ init_encounters_ui()

void init_encounters_ui ( void )

Definition at line 2814 of file encounter.c.

2814 {

2815}

Referenced by draw_encounter_ui().

◆ initialize_collision()

void initialize_collision ( void )

Definition at line 111 of file collision.c.

                                {
    gCollisionData.numColliders = 0;
    gZoneCollisionData.numColliders = 0;
    collision_heap_create();
}

Referenced by load_map_by_IDs(), state_step_demo(), state_step_end_battle(), state_step_intro(), state_step_startup(), and state_step_unpause().

◆ render_entities()

void render_entities ( void )

Definition at line 338 of file entity.c.

                           {
    s32 i;
 
    for (i = 0; i < MAX_ENTITIES; i++) {
        Entity* entity = get_entity_by_index(i);
 
        if (entity != NULL) {
            if (gGameStatusPtr->context == CONTEXT_WORLD) {
                if (gEntityHideMode != ENTITY_HIDE_MODE_0 &&
                    !(entity->flags & ENTITY_FLAG_IGNORE_DISTANCE_CULLING) &&
                    dist2D(gPlayerStatusPtr->pos.x,
                           gPlayerStatusPtr->pos.z,
                           entity->pos.x,
                           entity->pos.z) > 200.0f
                ) {
                    continue;
                }
 
                if (gEntityHideMode == ENTITY_HIDE_MODE_1) {
                    if (!(entity->flags & ENTITY_FLAG_DRAW_IF_CLOSE_HIDE_MODE1)) {
                        continue;
                    }
                } else if (gEntityHideMode == ENTITY_HIDE_MODE_2) {
                    if (!(entity->flags & ENTITY_FLAG_DRAW_IF_CLOSE_HIDE_MODE2)) {
                        continue;
                    }
                }
            }
 
            if (!(entity->flags & ENTITY_FLAG_HIDDEN)) {
                if (entity->flags & ENTITY_FLAG_HAS_ANIMATED_MODEL) {
                    if (D_8014AFB0 == 255) {
                        if (entity->renderSetupFunc != NULL) {
                            set_animator_render_callback(
                                entity->virtualModelIndex,
                                (void*)(u32) entity->listIndex,
                                (void (*)(void*)) entity->renderSetupFunc
                            );
                        }
                    } else {
                        set_animator_render_callback(
                            entity->virtualModelIndex,
                            (void*)(u32) entity->listIndex,
                            func_8010FE44
                        );
                    }
 
                    if (entity->gfxBaseAddr == NULL) {
                        render_animated_model(entity->virtualModelIndex, &entity->transformMatrix);
                    } else {
                        render_animated_model_with_vertices(entity->virtualModelIndex,
                                      &entity->transformMatrix,
                                      entity->vertexSegment,
                                      entity->gfxBaseAddr);
                    }
                } else {
                    if (D_8014AFB0 == 255) {
                        if (entity->renderSetupFunc != NULL) {
                            bind_entity_model_setupGfx(
                                entity->virtualModelIndex,
                                (void*)(u32) entity->listIndex,
                                (void (*)(void*)) entity->renderSetupFunc
                            );
                        } else {
                            get_entity_model(entity->virtualModelIndex)->fpSetupGfxCallback = NULL;
                        }
                    } else {
                        bind_entity_model_setupGfx(entity->virtualModelIndex, (void*)(u32)entity->listIndex, func_8010FE44);
                    }
 
                    if (entity->gfxBaseAddr == NULL) {
                        draw_entity_model_A(entity->virtualModelIndex, &entity->transformMatrix);
                    } else {
                        draw_entity_model_B(entity->virtualModelIndex,
                                               &entity->transformMatrix,
                                               entity->vertexSegment,
                                               entity->gfxBaseAddr);
                    }
                }
            }
        }
    }
 
    render_shadows();
}

Referenced by render_frame().

◆ render_player()

void render_player ( void )

Definition at line 1489 of file 77480.c.

                         {
    if (gGameStatusPtr->debugScripts == DEBUG_SCRIPTS_NONE) {
        render_player_model();
    }
}

Referenced by render_frame().

◆ render_workers_scene()

void render_workers_scene ( void )

Definition at line 137 of file worker.c.

                                {
    s32 i;
 
    for (i = 0; i < MAX_WORKERS; i++) {
        Worker* worker = (*gCurrentWorkerListPtr)[i];
        if (worker != NULL && !(worker->flags & WORKER_FLAG_SKIP_DRAW_UNTIL_UPDATE)) {
            if (!(worker->flags & WORKER_FLAG_FRONT_UI)) {
                worker->draw();
            }
        }
    }
}

Referenced by render_frame().

◆ render_effects_scene()

void render_effects_scene ( void )

Definition at line 116 of file effects.c.

                                {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gEffectInstances); i++) {
        EffectInstance* effectInstance = gEffectInstances[i];
 
        if (effectInstance != NULL) {
            if (effectInstance->flags & FX_INSTANCE_FLAG_ENABLED) {
                if (effectInstance->flags & FX_INSTANCE_FLAG_HAS_UPDATED) {
                    if (gGameStatusPtr->context != CONTEXT_WORLD) {
                        if (effectInstance->flags & FX_INSTANCE_FLAG_BATTLE) {
                            effectInstance->shared->renderScene(effectInstance);
                        }
                    } else {
                        if (!(effectInstance->flags & FX_INSTANCE_FLAG_BATTLE)) {
                            effectInstance->shared->renderScene(effectInstance);
                        }
                    }
                }
            }
        }
    }
}

Referenced by render_frame().

◆ get_asset_offset()

s32 get_asset_offset	(	char *	assetName,
		s32 *	compressedSize )

Definition at line 273 of file world.c.

                                                           {
    AssetHeader firstHeader;
    AssetHeader* assetTableBuffer;
    AssetHeader* curAsset;
    s32 ret;
 
    dma_copy((u8*) ASSET_TABLE_FIRST_ENTRY, (u8*) ASSET_TABLE_FIRST_ENTRY + sizeof(AssetHeader), &firstHeader);
    assetTableBuffer = heap_malloc(firstHeader.offset);
    curAsset = &assetTableBuffer[0];
    dma_copy((u8*) ASSET_TABLE_FIRST_ENTRY, (u8*) ASSET_TABLE_FIRST_ENTRY + firstHeader.offset, assetTableBuffer);
    while (strcmp(curAsset->name, assetName) != 0) {
        ASSERT_MSG(strcmp(curAsset->name, "end_data") != 0, "Asset not found: %s", assetName);
        curAsset++;
    }
    *compressedSize = curAsset->compressedLength;
    ret = ASSET_TABLE_FIRST_ENTRY + curAsset->offset;
    heap_free(assetTableBuffer);
    return ret;
}

Referenced by btl_state_update_normal_start(), load_map_by_IDs(), and state_step_end_battle().

◆ initialize_status_bar()

void initialize_status_bar ( void )

Definition at line 483 of file inventory.c.

                                 {
    StatusBar* statusBar = &gStatusBar;
    PlayerData* playerData = &gPlayerData;
    HudElemID hid;
 
    statusBar->drawPosX = 12;
    ShowingCoinCounter = FALSE;
    HidingCoinCounter = FALSE;
    statusBar->drawPosY = FULLY_RETRACTED_Y;
    statusBar->hidden = FALSE;
    statusBar->showTimer = 210;
    statusBar->unk_3B = FALSE;
    statusBar->ignoreChanges = FALSE;
    statusBar->openInputDisabled = FALSE;
    statusBar->alwaysShown = FALSE;
    statusBar->hpBlinking = BLINK_OFF;
    statusBar->hpBlinkAnimTime = 0;
    statusBar->hpBlinkTimeLeft = 0;
    statusBar->fpBlinking = BLINK_OFF;
    statusBar->fpBlinkAnimTime = 0;
    statusBar->fpBlinkTimeLeft = 0;
    statusBar->starPowerBlinking = BLINK_OFF;
    statusBar->starPowerBlinkCounter = 0;
    statusBar->coinsBlinking = BLINK_OFF;
    statusBar->coinsBlinkAnimTime = 0;
    statusBar->coinsBlinkTimeLeft = 0;
    statusBar->disabled = 0;
    statusBar->starpointsBlinking = BLINK_OFF;
    statusBar->displayHP = playerData->curHP;
    statusBar->displayFP = playerData->curFP;
    statusBar->displayCoins = playerData->coins;
    statusBar->displayStarpoints = playerData->starPoints;
    statusBar->displayStarPower = playerData->starPower;
    statusBar->starpointsBlinkAnimTime = 0;
    statusBar->prevIgnoreChanges = -1;
    statusBar->unk_3C = FALSE;
    statusBar->shimmerState = STATUS_SHIMMER_OFF;
    statusBar->shimmerTime = 0;
    statusBar->shimmerLimit = 0;
    statusBar->powBarsToBlink = 0;
    statusBar->coinCounterHideDelay = 0;
    statusBar->coinCountDisposeTime = 0;
    statusBar->iconIndex12 = -1;
 
    close_status_bar();
 
#if VERSION_PAL
    switch (gCurrentLanguage) {
        case LANGUAGE_EN:
            hid = statusBar->hpIconHIDs[0] = hud_element_create(&HES_StatusHP);
            break;
        case LANGUAGE_DE:
            hid = statusBar->hpIconHIDs[0] = hud_element_create(&HES_StatusHP_de);
            break;
        case LANGUAGE_FR:
            hid = statusBar->hpIconHIDs[0] = hud_element_create(&HES_StatusHP_fr);
            break;
        case LANGUAGE_ES:
            hid = statusBar->hpIconHIDs[0] = hud_element_create(&HES_StatusHP_es);
            break;
    }
 
    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_FILTER_TEX);
#else
    statusBar->hpIconHIDs[0] = hid = hud_element_create(&HES_StatusHP);
    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_FILTER_TEX);
#endif
 
    statusBar->hpIconHIDs[1] = hid = hud_element_create(&HES_StatusHeart);
    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_FILTER_TEX);
 
#if VERSION_PAL
    switch (gCurrentLanguage) {
        case LANGUAGE_EN:
            hid = statusBar->fpIconHIDs[0] = hud_element_create(&HES_StatusFP);
            break;
        case LANGUAGE_DE:
            hid = statusBar->fpIconHIDs[0] = hud_element_create(&HES_StatusFP_de);
            break;
        case LANGUAGE_FR:
            hid = statusBar->fpIconHIDs[0] = hud_element_create(&HES_StatusFP_fr);
            break;
        case LANGUAGE_ES:
            hid = statusBar->fpIconHIDs[0] = hud_element_create(&HES_StatusFP_es);
            break;
    }
 
    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_FILTER_TEX);
#else
    statusBar->fpIconHIDs[0] = hid = hud_element_create(&HES_StatusFP);
    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_FILTER_TEX);
#endif
 
    statusBar->fpIconHIDs[1] = hid = hud_element_create(&HES_StatusFlower);
    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_FILTER_TEX);
 
    statusBar->coinIconHID = hid = hud_element_create(&HES_StatusCoin);
    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_FILTER_TEX);
 
    statusBar->coinSparkleHID = hid = hud_element_create(&HES_StatusCoinSparkle);
    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_FILTER_TEX);
 
    statusBar->spIconHID = hid = hud_element_create(&HES_StatusStarPoint);
    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_FILTER_TEX);
 
    statusBar->spShineHID = hid = hud_element_create(&HES_StatusSPShine);
    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_FILTER_TEX);
 
    statusBar->hpTimesHID = hid = hud_element_create(&HES_StatusTimes);
    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80 | HUD_ELEMENT_FLAG_DISABLED);
    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_FILTER_TEX);
 
    statusBar->fpTimesHID = hid = hud_element_create(&HES_StatusTimes);
    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80 | HUD_ELEMENT_FLAG_DISABLED);
    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_FILTER_TEX);
 
    statusBar->spTimesHID = hid = hud_element_create(&HES_StatusTimes);
    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80 | HUD_ELEMENT_FLAG_DISABLED);
    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_FILTER_TEX);
 
    statusBar->coinTimesHID = hid = hud_element_create(&HES_StatusTimes);
    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80 | HUD_ELEMENT_FLAG_DISABLED);
    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_FILTER_TEX);
 
    statusBar->starIconHID = hid = hud_element_create(&HES_StatusStar1);
    hud_element_set_flags(hid, HUD_ELEMENT_FLAG_80);
    hud_element_clear_flags(hid, HUD_ELEMENT_FLAG_FILTER_TEX);
 
    star_power_shimmer_init();
}

Referenced by load_demo_battle(), and load_map_by_IDs().

◆ status_bar_start_blinking_fp()

void status_bar_start_blinking_fp ( void )

Definition at line 1564 of file inventory.c.

                                        {
    StatusBar* statusBar = &gStatusBar;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        statusBar->fpBlinkTimeLeft = 120;
    }
 
    if (statusBar->fpBlinking != BLINK_ON) {
        statusBar->fpBlinking = BLINK_ON;
        statusBar->fpBlinkAnimTime = 0;
    }
}

Referenced by btl_menu_moves_draw_content(), and update_status_bar().

◆ is_status_bar_visible()

s32 is_status_bar_visible ( void )

Definition at line 1537 of file inventory.c.

                                {
    return !gStatusBar.hidden;
}

Referenced by check_input_status_bar().

◆ status_bar_start_blinking_starpoints()

void status_bar_start_blinking_starpoints ( void )

Definition at line 1639 of file inventory.c.

                                                {
    StatusBar* statusBar = &gStatusBar;
 
    if (statusBar->starpointsBlinking != BLINK_ON) {
        statusBar->starpointsBlinking = BLINK_ON;
        statusBar->starpointsBlinkAnimTime = 0;
    }
}

Referenced by btl_state_update_run_away().

◆ status_bar_stop_blinking_starpoints()

void status_bar_stop_blinking_starpoints ( void )

Definition at line 1648 of file inventory.c.

                                               {
    StatusBar* statusBar = &gStatusBar;
 
    if (statusBar->starpointsBlinking != BLINK_OFF) {
        statusBar->starpointsBlinking = BLINK_OFF;
        statusBar->starpointsBlinkAnimTime = 0;
    }
}

Referenced by btl_state_update_run_away().

◆ status_bar_start_blinking_hp()

void status_bar_start_blinking_hp ( void )

Definition at line 1541 of file inventory.c.

                                        {
    StatusBar* statusBar = &gStatusBar;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        statusBar->hpBlinkTimeLeft = 120;
    }
 
    if (statusBar->hpBlinking != BLINK_ON) {
        statusBar->hpBlinking = BLINK_ON;
        statusBar->hpBlinkAnimTime = 0;
    }
}

Referenced by update_status_bar().

◆ status_bar_start_blinking_sp()

void status_bar_start_blinking_sp ( void )

Definition at line 1609 of file inventory.c.

                                        {
    PlayerData* playerData = &gPlayerData;
    StatusBar* statusBar = &gStatusBar;
 
    statusBar->powBarsToBlink = playerData->maxStarPower;
    if (statusBar->starPowerBlinking != BLINK_ON) {
        statusBar->starPowerBlinking = BLINK_ON;
        statusBar->starPowerBlinkCounter = 0;
    }
}

◆ status_bar_stop_blinking_fp()

void status_bar_stop_blinking_fp ( void )

Definition at line 1577 of file inventory.c.

                                       {
    StatusBar* statusBar = &gStatusBar;
 
    if (statusBar->fpBlinking != BLINK_OFF) {
        statusBar->fpBlinking = BLINK_OFF;
        statusBar->fpBlinkAnimTime = 0;
    }
}

Referenced by btl_menu_moves_draw_content(), btl_submenu_moves_update(), and update_status_bar().

◆ status_bar_stop_blinking_hp()

void status_bar_stop_blinking_hp ( void )

Definition at line 1554 of file inventory.c.

                                       {
    StatusBar* statusBar = &gStatusBar;
 
    if (statusBar->hpBlinking != BLINK_OFF) {
        statusBar->hpBlinking = BLINK_OFF;
        statusBar->hpBlinkAnimTime = 0;
        statusBar->hpBlinkTimeLeft = 0;
    }
}

Referenced by update_status_bar().

◆ status_bar_stop_blinking_sp()

void status_bar_stop_blinking_sp ( void )

Definition at line 1620 of file inventory.c.

                                       {
    StatusBar* statusBar = &gStatusBar;
 
    if (statusBar->starPowerBlinking != BLINK_OFF) {
        statusBar->starPowerBlinking = BLINK_OFF;
        statusBar->starPowerBlinkCounter = 0;
    }
}

Referenced by btl_menu_moves_draw_content(), and btl_submenu_moves_update().

◆ status_bar_start_blinking_sp_bars()

void status_bar_start_blinking_sp_bars ( s32 numBarsToBlink )

Definition at line 1629 of file inventory.c.

                                                           {
    StatusBar* statusBar = &gStatusBar;
 
    statusBar->powBarsToBlink = numBarsToBlink;
    if (statusBar->starPowerBlinking != BLINK_ON) {
        statusBar->starPowerBlinking = BLINK_ON;
        statusBar->starPowerBlinkCounter = 0;
    }
}

Referenced by btl_menu_moves_draw_content().

◆ status_bar_draw_number()

void status_bar_draw_number	(	s32	iconID,
		s32	x,
		s32	y,
		s32	value,
		s32	numDigits )

Definition at line 624 of file inventory.c.

                                                                                          {
    s8 digits[4];
    s32 drawX, drawY;
    b32 keepDrawing;
    s32 digit;
    s32 i;
 
    hud_element_set_script(iconID, TimesHudScript);
    drawX = startX + 8;
    drawY = startY + 8;
    hud_element_set_render_pos(iconID, drawX, drawY - 1);
    hud_element_clear_flags(iconID, HUD_ELEMENT_FLAG_DISABLED);
    hud_element_draw_next(iconID);
 
    // Write each digit of the input number into the digits array
    for (i = 0; i < numDigits; i++) {
        digit = value % 10;
        digits[(numDigits - i) - 1] = digit;
        value /= 10;
    }
 
    drawX += 13;
    keepDrawing = FALSE;
 
    for (i = 0; i < numDigits; i++, drawX += 8) {
        digit = digits[i];
 
        // Once we have encountered our first non-zero digit, we need to keep drawing the remaining digits
        if (digit != 0 || keepDrawing || (i == numDigits - 1)) {
            keepDrawing = TRUE;
            hud_element_set_script(iconID, DigitHudScripts[digit]);
            hud_element_set_render_pos(iconID, drawX, drawY);
            hud_element_clear_flags(iconID, HUD_ELEMENT_FLAG_DISABLED);
            hud_element_draw_next(iconID);
        }
    }
}

Referenced by update_status_bar().

◆ status_bar_draw_stat()

void status_bar_draw_stat	(	s32	id,
		s32	x,
		s32	y,
		s32	currentValue,
		s32	maxValue )

Definition at line 662 of file inventory.c.

                                                                                          {
    s8 digits[4];
    b32 keepDrawing;
    s32 digit;
    s32 numDigits = 2;
    s32 drawX;
    s32 drawY;
    s32 i = 0;
    s32 baseX = startX + 8;
    s32 baseY = startY + 8;
 
    hud_element_set_script(id, SlashHudScript);
    hud_element_set_render_pos(id, baseX + 14, baseY + 1);
    hud_element_clear_flags(id, HUD_ELEMENT_FLAG_DISABLED);
    hud_element_draw_next(id);
 
    for (i = 0; i < numDigits; i++) {
        s32 num = currentValue % 10;
        digits[numDigits - i - 1] = num;
        currentValue /= 10;
    }
 
    drawX = baseX;
    drawY = baseY;
    keepDrawing = FALSE;
    for (i = 0; i < numDigits; i++, drawX += 8) {
        digit = digits[i];
        if (digit != 0 || keepDrawing || i == numDigits - 1) {
            keepDrawing = TRUE;
            hud_element_set_script(id, DigitHudScripts[digit]);
            hud_element_set_render_pos(id, drawX, drawY);
            hud_element_clear_flags(id, HUD_ELEMENT_FLAG_DISABLED);
            hud_element_draw_next(id);
        }
    }
 
    for (i = 0; i < numDigits; i++) {
        digits[numDigits - i - 1] = maxValue % 10;
        maxValue /= 10;
    }
 
    drawX = baseX + 26;
    drawY = baseY;
    keepDrawing = FALSE;
    for (i = 0; i < numDigits; i++, drawX += 8) {
        digit = digits[i];
        if (digit != 0 || keepDrawing || i == numDigits - 1) {
            keepDrawing = TRUE;
            hud_element_set_script(id, DigitHudScripts[digit]);
            hud_element_set_render_pos(id, drawX, drawY);
            hud_element_clear_flags(id, HUD_ELEMENT_FLAG_DISABLED);
            hud_element_draw_next(id);
        }
    }
}

Referenced by update_status_bar().

◆ set_background_size()

void set_background_size	(	s16	startX,
		s16	startY,
		s16	sizeX,
		s16	sizeY )

Definition at line 50 of file background.c.

                                                                       {
    gGameStatusPtr->backgroundFlags &= ~BACKGROUND_FLAG_TEXTURE;
    gGameStatusPtr->backgroundMaxX = startX;
    gGameStatusPtr->backgroundMaxY = startY;
    gGameStatusPtr->backgroundMinX = sizeX;
    gGameStatusPtr->backgroundMinY = sizeY;
}

Referenced by load_map_by_IDs(), state_step_end_battle(), and state_step_unpause().

◆ set_background()

void set_background ( BackgroundHeader * bg )

Definition at line 40 of file background.c.

                                          {
    gGameStatusPtr->backgroundMaxX = bg->width;
    gGameStatusPtr->backgroundMaxY = bg->height;
    gGameStatusPtr->backgroundMinX = bg->startX;
    gGameStatusPtr->backgroundMinY = bg->startY;
    gGameStatusPtr->backgroundRaster = bg->raster;
    gGameStatusPtr->backgroundPalette = bg->palette;
    gGameStatusPtr->backgroundFlags |= BACKGROUND_FLAG_TEXTURE;
}

Referenced by btl_state_update_normal_start(), load_map_by_IDs(), state_init_title_screen(), state_step_end_battle(), and state_step_unpause().

◆ set_max_star_power()

void set_max_star_power ( s8 newMax )

Definition at line 2140 of file inventory.c.

                                   {
    gPlayerData.maxStarPower = newMax;
    gPlayerData.starPower = newMax * SP_PER_BAR;
}

◆ sync_status_bar()

void sync_status_bar ( void )

Definition at line 1671 of file inventory.c.

                           {
    PlayerData* playerData = &gPlayerData;
    StatusBar* statusBar = &gStatusBar;
 
    statusBar->displayHP = playerData->curHP;
    statusBar->displayFP = playerData->curFP;
    statusBar->displayStarPower = playerData->starPower;
    statusBar->displayCoins = playerData->coins;
    statusBar->displayStarpoints = playerData->starPoints;
}

◆ create_cameras()

void create_cameras ( void )

Definition at line 255 of file cam_main.c.

                          {
    CameraInitData camData;
    CameraInitData* camDataPtr = &camData;
    s32 i;
 
    CamLengthScale = 1.0f;
 
    for (i = 0; i < ARRAY_COUNT(gCameras); i++) {
        gCameras[i].flags = 0;
    }
 
    camDataPtr->flags = CAMERA_FLAG_DISABLED;
    camDataPtr->updateMode = CAM_UPDATE_MINIMAL;
    camDataPtr->viewWidth = 160;
    camDataPtr->viewHeight = 120;
    camDataPtr->viewStartX = 0;
    camDataPtr->viewStartY = 0;
    camDataPtr->nearClip = 8;
    camDataPtr->farClip = 16384;
    camDataPtr->vfov = 50;
    initialize_next_camera(camDataPtr);
 
    camDataPtr->flags = CAMERA_FLAG_DISABLED;
    camDataPtr->updateMode = CAM_UPDATE_MINIMAL;
    camDataPtr->viewWidth = 160;
    camDataPtr->viewHeight = 120;
    camDataPtr->viewStartX = 160;
    camDataPtr->viewStartY = 0;
    camDataPtr->nearClip = 8;
    camDataPtr->farClip = 16384;
    camDataPtr->vfov = 50;
    initialize_next_camera(camDataPtr);
 
    camDataPtr->flags = CAMERA_FLAG_DISABLED;
    camDataPtr->updateMode = CAM_UPDATE_MINIMAL;
    camDataPtr->viewWidth = 160;
    camDataPtr->viewHeight = 120;
    camDataPtr->viewStartX = 0;
    camDataPtr->viewStartY = 120;
    camDataPtr->nearClip = 8;
    camDataPtr->farClip = 16384;
    camDataPtr->vfov = 50;
    initialize_next_camera(camDataPtr);
 
    camDataPtr->flags = CAMERA_FLAG_DISABLED;
    camDataPtr->updateMode = CAM_UPDATE_MINIMAL;
    camDataPtr->viewWidth = 160;
    camDataPtr->viewHeight = 120;
    camDataPtr->viewStartX = 160;
    camDataPtr->viewStartY = 120;
    camDataPtr->nearClip = 8;
    camDataPtr->farClip = 16384;
    camDataPtr->vfov = 50;
    initialize_next_camera(camDataPtr);
}

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

◆ func_80045AC0()

void func_80045AC0 ( void )

Definition at line 125 of file status_icons.c.

                         {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(D_800A0BC0); i++) {
        PopupMessage* popup = &D_800A0BC0[i];
        popup->active = FALSE;
        popup->data.icons = NULL;
    }
 
    create_worker_scene(NULL, func_80045BC8);
    init_all_status_icons();
}

Referenced by clear_encounter_status(), and init_encounter_status().

◆ func_8005AF84()

void func_8005AF84 ( void )

Definition at line 105 of file collision.c.

105 {

106}

Referenced by state_step_end_battle(), and state_step_unpause().

◆ npc_follow_init()

void npc_follow_init	(	Npc *	npc,
		s32	targetNpcID,
		FollowAnims *	anims,
		f32	walkSpeed,
		f32	runSpeed,
		s32	idleRadius,
		s32	walkRadius )

Definition at line 38 of file npc_follow.c.

                                                                                                                                 {
    PlayerStatus* playerStatus = &gPlayerStatus;
    NpcFollowData* followData;
    s32 i;
 
    npc->blur.followData = followData = heap_malloc(sizeof(*followData));
    ASSERT(followData != NULL);
 
    for (i = 0; i < ARRAY_COUNT(followData->moveHistory); i++) {
        followData->moveHistory[i].pos.x = playerStatus->pos.x;
        followData->moveHistory[i].pos.y = playerStatus->pos.y;
        followData->moveHistory[i].pos.z = playerStatus->pos.z;
        followData->moveHistory[i].isAirborne = FALSE;
    }
    followData->lastPointIdx = 0;
    followData->targetPointIdx = 0;
    followData->followState = NPC_FOLLOW_STATE_RUN;
    followData->targetNpcID = targetNpcID;
    followData->anims = anims;
    followData->walkSpeed = walkSpeed;
    followData->runSpeed = runSpeed;
    followData->idleRadius = idleRadius;
    followData->walkRadius = walkRadius;
    npc->curAnim = followData->anims->idle;
    npc->jumpVel = 0.0f;
    npc->flags |= NPC_FLAG_GRAVITY;
    npc->flags &= ~NPC_FLAG_IGNORE_PLAYER_COLLISION;
    npc->collisionChannel = COLLIDER_FLAG_IGNORE_PLAYER;
}

◆ npc_update_npc_tracking()

void npc_update_npc_tracking ( Npc * npc )

Definition at line 68 of file npc_follow.c.

                                       {
    NpcFollowData* followData = npc->blur.followData;
    f32 x, y, z;
    s32 airborne;
    s32 isAirborne;
    NpcHistoryPoint* historyPoint;
 
    get_npc_pos(followData->targetNpcID, &x, &y, &z, &airborne);
    historyPoint = &followData->moveHistory[followData->lastPointIdx];
    isAirborne = airborne != FALSE;
 
    if (historyPoint->isAirborne && isAirborne) {
        return;
    }
 
    if (!isAirborne && dist2D(npc->pos.x, npc->pos.z, x, z) <= followData->idleRadius && !historyPoint->isAirborne) {
        return;
    }
 
    historyPoint = &followData->moveHistory[followData->lastPointIdx];
    if (historyPoint->pos.x != x || historyPoint->pos.y != y || historyPoint->pos.z != z) {
        if (followData->targetPointIdx != followData->lastPointIdx + 1) {
            followData->lastPointIdx++;
            if (followData->lastPointIdx >= ARRAY_COUNT(followData->moveHistory)) {
                followData->lastPointIdx = 0;
            }
            historyPoint = &followData->moveHistory[followData->lastPointIdx];
            historyPoint->pos.x = x;
            historyPoint->pos.y = y;
            historyPoint->pos.z = z;
            historyPoint->isAirborne = isAirborne;
        }
    }
}

◆ npc_follow_npc()

void npc_follow_npc ( Npc * npc )

Definition at line 103 of file npc_follow.c.

                              {
    NpcFollowData* followData = npc->blur.followData;
    f32 x, y, z;
    s32 airborne;
    f32 currentX, currentY, currentZ;
    f32 dist;
    NpcHistoryPoint* historyPoint;
    f32 targetX, targetY, targetZ;
    f32 theta;
    f32 yaw;
 
    get_npc_pos(followData->targetNpcID, &x, &y, &z, &airborne);
 
    switch (followData->followState) {
        case NPC_FOLLOW_STATE_RUN:
            historyPoint = &followData->moveHistory[followData->targetPointIdx];
            targetX = historyPoint->pos.x;
            targetY = historyPoint->pos.y;
            targetZ = historyPoint->pos.z;
            currentX = npc->pos.x;
            currentY = npc->pos.y;
            currentZ = npc->pos.z;
            npc->moveSpeed = followData->walkSpeed;
 
            dist = dist2D(npc->pos.x, npc->pos.z, x, z);
            if (dist >= followData->walkRadius) {
                npc->moveSpeed = followData->runSpeed;
            }
 
            npc->curAnim = followData->anims->run;
            if (!(npc->flags & NPC_FLAG_GROUNDED)) {
                npc->curAnim = followData->anims->fall;
            }
 
            while (TRUE) {
                dist = dist2D(currentX, currentZ, targetX, targetZ);
                yaw = atan2(currentX, currentZ, targetX, targetZ);
                if (dist > npc->moveSpeed) {
                    dist = dist2D(currentX, currentZ, x, z);
                    if (dist > followData->walkRadius) {
                        break;
                    }
 
                    if (dist > followData->idleRadius) {
                        npc->moveSpeed = dist - followData->idleRadius;
                        if (npc->moveSpeed > followData->walkSpeed) {
                            npc->moveSpeed = followData->walkSpeed;
                        } else {
                            npc->moveSpeed += 1.0;
                        }
                        break;
                    }
                }
 
                if (followData->targetPointIdx == followData->lastPointIdx) {
                    npc->moveSpeed = 0.0f;
                    yaw = npc->yaw;
                    npc->curAnim = followData->anims->idle;
                    break;
                }
 
                dist = dist2D(npc->pos.x, npc->pos.z, x, z);
                if (dist <= followData->idleRadius) {
                    npc->moveSpeed = 0.0f;
                    yaw = npc->yaw;
                    npc->curAnim = followData->anims->idle;
                    followData->followState = NPC_FOLLOW_STATE_IDLE;
                    break;
                }
 
                followData->targetPointIdx++;
                if (followData->targetPointIdx >= ARRAY_COUNT(followData->moveHistory)) {
                    followData->targetPointIdx = 0;
                }
                historyPoint = &followData->moveHistory[followData->targetPointIdx];
                targetX = historyPoint->pos.x;
                targetZ = historyPoint->pos.z;
                if (npc->flags & NPC_FLAG_GROUNDED) {
                    if (historyPoint->isAirborne) {
                        followData->followState = NPC_FOLLOW_STATE_JUMP;
                        break;
                    }
                }
            }
 
            if (!(npc->flags & NPC_FLAG_GROUNDED)) {
                npc->moveSpeed *= 0.5f;
            }
            npc->yaw = yaw;
            npc_move_heading(npc, npc->moveSpeed, yaw);
            if ((npc->flags & NPC_FLAG_COLLDING_FORWARD_WITH_WORLD) && (npc->flags & NPC_FLAG_GROUNDED)) {
                followData->followState = NPC_FOLLOW_STATE_JUMP;
            }
            break;
        case NPC_FOLLOW_STATE_JUMP:
            if (followData->targetPointIdx != followData->lastPointIdx) {
                followData->targetPointIdx++;
                if (followData->targetPointIdx >= ARRAY_COUNT(followData->moveHistory)) {
                    followData->targetPointIdx = 0;
                }
                historyPoint = &followData->moveHistory[followData->targetPointIdx];
                targetX = historyPoint->pos.x;
                targetY = historyPoint->pos.y;
                targetZ = historyPoint->pos.z;
                npc->moveToPos.x = targetX;
                npc->moveToPos.y = targetY;
                npc->moveToPos.z = targetZ;
                npc->duration = 0;
                npc->jumpScale = 2.0f;
                npc->moveSpeed = followData->runSpeed;
                npc->planarFlyDist = dist2D(npc->pos.x, npc->pos.z, npc->moveToPos.x, npc->moveToPos.z);
                npc->yaw = atan2(npc->pos.x, npc->pos.z, npc->moveToPos.x, npc->moveToPos.z);
                dist = npc->planarFlyDist;
                currentY = npc->moveToPos.y - npc->pos.y;
                if (npc->planarFlyDist < currentY) {
                    dist = currentY;
                }
                if (dist < followData->idleRadius) {
                    npc->jumpVel = 0.0f;
                    npc->flags |= NPC_FLAG_GRAVITY;
                    npc->yaw = atan2(npc->pos.x, npc->pos.z, x, z);
                    followData->followState = NPC_FOLLOW_STATE_RUN;
                    return;
                }
                npc->duration = dist / npc->moveSpeed;
                if (npc->duration < 10) {
                    npc->duration = 10;
                }
                npc->moveSpeed = npc->planarFlyDist / npc->duration;
                npc->jumpVel = (currentY + (npc->jumpScale * npc->duration * npc->duration * 0.5f)) / npc->duration;
                npc->curAnim = followData->anims->jump;
                npc->flags &= ~NPC_FLAG_GRAVITY;
                followData->followState = NPC_FOLLOW_STATE_FALL;
            }
            break;
        case NPC_FOLLOW_STATE_FALL:
            npc->jumpVel -= npc->jumpScale;
            npc->pos.y += npc->jumpVel;
            if (npc->jumpVel <= 0.0f) {
                npc->curAnim = followData->anims->fall;
            }
            npc_move_heading(npc, npc->moveSpeed, npc->yaw);
            if (npc->jumpVel <= 0.0f) {
                currentX = npc->pos.x;
                dist = fabsf(npc->jumpVel) + 8.0;
                currentY = npc->pos.y + dist;
                currentZ = npc->pos.z;
                if (npc_raycast_down_sides(npc->collisionChannel, &currentX, &currentY, &currentZ, &dist) != 0 &&
                    dist <= fabsf(npc->jumpVel) + 8.0)
                {
                    npc->curAnim = followData->anims->land;
                    npc->jumpVel = 0.0f;
                    npc->pos.y = currentY;
                    npc->flags |= NPC_FLAG_GRAVITY;
                    npc->yaw = atan2(currentX, currentZ, x, z);
                    followData->followState = NPC_FOLLOW_STATE_RUN;
                }
            }
            break;
        case NPC_FOLLOW_STATE_IDLE:
            historyPoint = &followData->moveHistory[followData->targetPointIdx];
            targetX = historyPoint->pos.x;
            targetY = historyPoint->pos.y;
            targetZ = historyPoint->pos.z;
            currentX = npc->pos.x;
            currentY = npc->pos.y;
            currentZ = npc->pos.z;
            dist = dist2D(npc->pos.x, npc->pos.z, x, z);
            if (dist <= followData->idleRadius) {
                break;
            }
 
            while (TRUE) {
                if (historyPoint->isAirborne) {
                    break;
                }
 
                yaw = atan2(npc->pos.x, npc->pos.z, targetX, targetZ);
                if (fabsf(get_clamped_angle_diff(yaw, atan2(npc->pos.x, npc->pos.z, x, z))) < 90.0f) {
                    break;
                }
 
                if (followData->targetPointIdx == followData->lastPointIdx) {
                    break;
                }
 
                followData->targetPointIdx++;
                if (followData->targetPointIdx >= ARRAY_COUNT(followData->moveHistory)) {
                    followData->targetPointIdx = 0;
                }
                historyPoint = &followData->moveHistory[followData->targetPointIdx];
                targetX = historyPoint->pos.x;
                targetZ = historyPoint->pos.z;
                continue;
            }
 
            if (!historyPoint->isAirborne) {
                followData->followState = NPC_FOLLOW_STATE_RUN;
                return;
            }
 
            while (TRUE) {
                if (!historyPoint->isAirborne) {
                    break;
                }
 
                yaw = atan2(npc->pos.x, npc->pos.z, targetX, targetZ);
                if (fabsf(get_clamped_angle_diff(yaw, atan2(npc->pos.x, npc->pos.z, x, z))) < 90.0f) {
                    break;
                }
 
                if (followData->targetPointIdx == followData->lastPointIdx) {
                    break;
                }
 
                followData->targetPointIdx++;
                if (followData->targetPointIdx >= ARRAY_COUNT(followData->moveHistory)) {
                    followData->targetPointIdx = 0;
                }
                historyPoint = &followData->moveHistory[followData->targetPointIdx];
                targetX = historyPoint->pos.x;
                targetZ = historyPoint->pos.z;
            }
            followData->followState = NPC_FOLLOW_STATE_JUMP;
            break;
    }
}

◆ create_encounters()

void create_encounters ( void )

Definition at line 2461 of file encounter.c.

                             {
    EncounterStatus* currentEncounter = &gCurrentEncounter;
    NpcBlueprint sp10;
    NpcBlueprint* bp = &sp10;
    NpcGroup* groupList = (NpcGroup*)(currentEncounter->npcGroupList);
    s32 groupNpcCount;
    s32 mapID = currentEncounter->mapID;
 
    Npc* newNpc;
    s32 newNpcIndex;
    s32 npcCount;
 
    NpcSettings* npcSettings;
    NpcData* npcData;
    Enemy* enemy;
    Encounter* encounter;
    Evt* script;
 
    s32 totalNpcCount;
 
    s32 cond1;
    s32 cond2;
    s32 i;
    s32 k;
    s32 e;
 
    switch (gEncounterSubState) {
        case ENCOUNTER_SUBSTATE_CREATE_INIT:
            if (currentEncounter->resetMapEncounterFlags != 1) {
                // check for current map among most recently visited
                for (i = 0; i < ARRAY_COUNT(currentEncounter->recentMaps); i++) {
                    if (currentEncounter->recentMaps[i] == mapID) {
                        break;
                    }
                }
                // current map not found in recent: reset all defeat flags
                if (i >= ARRAY_COUNT(currentEncounter->recentMaps)) {
                    for (k = 0; k < ARRAY_COUNT(currentEncounter->defeatFlags[mapID]); k++) {
                        currentEncounter->defeatFlags[mapID][k] = FALSE;
                    }
                }
                // add current map to recent maps, pushing out the least recent
                for (i = 0; i < ARRAY_COUNT(currentEncounter->recentMaps) - 1; i++) {
                    currentEncounter->recentMaps[i] = currentEncounter->recentMaps[i + 1];
                }
                currentEncounter->recentMaps[i] = mapID;
            }
 
            e = 0;
            totalNpcCount = 0;
            while (TRUE) {
                if (groupList->npcCount == 0) {
                    break;
                }
 
                npcData = groupList->npcs;
                groupNpcCount = groupList->npcCount;
 
                encounter = heap_malloc(sizeof(*encounter));
 
                currentEncounter->encounterList[e] = encounter;
                ASSERT(encounter != NULL);
                encounter->count = groupNpcCount;
                encounter->battle = groupList->battle;
                encounter->stage = groupList->stage - 1;
                encounter->encounterID = totalNpcCount;
                for (i = 0; i < groupNpcCount; i++) {
                    if (get_defeated(mapID, encounter->encounterID + i)) {
                        npcData++;
                        encounter->enemy[i] = NULL;
                        continue;
                    }
 
                    enemy = encounter->enemy[i] = heap_malloc(sizeof(*enemy));
                    ASSERT (enemy != NULL);
 
                    for (k = 0; k < ARRAY_COUNT(enemy->varTable); k++) {
                        enemy->varTable[k] = 0;
                    }
                    enemy->encounterIndex = e;
                    enemy->npcID = npcData->id;
                    npcSettings = enemy->npcSettings = npcData->settings;
                    enemy->drops = &npcData->drops;
                    if ((*(s16*)(&npcData->drops) & 0xFF00) != 0x8000) { //TODO s16?
                        enemy->drops = &DefaultEnemyDrops;
                    }
                    enemy->encountered = 0;
                    if ((s32) npcData->init < EVT_LIMIT) {
                        enemy->initBytecode = npcData->init;
                    } else {
                        enemy->initBytecode = NULL;
                    }
                    enemy->interactBytecode = npcSettings->onInteract;
                    enemy->aiBytecode = npcSettings->ai;
                    enemy->hitBytecode = npcSettings->onHit;
                    enemy->auxBytecode = npcSettings->aux;
                    enemy->defeatBytecode = npcSettings->onDefeat;
                    enemy->initScript = NULL;
                    enemy->interactScript = NULL;
                    enemy->aiScript = NULL;
                    enemy->hitScript = NULL;
                    enemy->auxScript = NULL;
                    enemy->defeatScript = NULL;
                    enemy->interactScriptID = 0;
                    enemy->aiScriptID = 0;
                    enemy->hitScriptID = 0;
                    enemy->auxScriptID = 0;
                    enemy->defeatScriptID = 0;
                    enemy->hitboxIsActive = FALSE;
                    enemy->instigatorValue = 0;
                    enemy->aiDetectFlags = npcData->aiDetectFlags;
 
                    enemy->aiFlags = npcData->aiFlags;
                    enemy->unk_DC = 0;
                    enemy->aiSuspendTime = 0;
                    enemy->unk_B8 = (EvtScript*)npcSettings->unk_24; // ??
                    enemy->unk_BC = NULL;
                    enemy->unk_C0 = 0;
                    enemy->unk_C4 = 0;
 
                    enemy->animList = (s32*)&npcData->animations;
                    enemy->territory = &npcData->territory;
 
                    enemy->flags = npcSettings->flags;
                    enemy->flags |= npcData->flags;
                    enemy->unk_64 = NULL;
                    enemy->tattleMsg = npcData->tattle;
                    if (npcData->initVarCount != 0) {
                        if (npcData->initVarCount == 1) {
                            enemy->varTable[0] = npcData->initVar.value;
                        } else {
                            s32* initialVars = npcData->initVar.array;
                            for (k = 0; k < npcData->initVarCount; k++) {
                                enemy->varTable[k] = *initialVars++;
                            }
                        }
                    }
 
                    // create the new NPC
                    bp->flags = 0;
                    if (npcSettings->defaultAnim == 0) {
                        bp->initialAnim = enemy->animList[0];
                    } else {
                        bp->initialAnim = npcSettings->defaultAnim;
                    }
                    bp->onUpdate = NULL;
                    bp->onRender = NULL;
                    if (!(enemy->flags & ENEMY_FLAG_USE_PLAYER_SPRITE)) {
                        newNpcIndex = create_standard_npc(bp, npcData->extraAnimations);
                    } else {
                        newNpcIndex = create_peach_npc(bp);
                    }
 
                    newNpc = get_npc_by_index(newNpcIndex);
                    newNpc->npcID = npcData->id;
                    newNpc->collisionDiameter = npcSettings->radius;
                    newNpc->collisionHeight = npcSettings->height;
                    enemy->spawnPos[0] = newNpc->pos.x = npcData->pos.x;
                    enemy->spawnPos[1] = newNpc->pos.y = npcData->pos.y;
                    enemy->spawnPos[2] = newNpc->pos.z = npcData->pos.z;
                    newNpc->unk_96 = 0;
                    newNpc->planarFlyDist = 0.0f;
                    newNpc->homePos.x = newNpc->pos.x;
                    newNpc->homePos.y = newNpc->pos.y;
                    newNpc->homePos.z = newNpc->pos.z;
                    set_npc_yaw(newNpc, npcData->yaw);
                    enemy->savedNpcYaw = 12345;
                    if (newNpc->collisionDiameter >= 24.0) {
                        newNpc->shadowScale = newNpc->collisionDiameter / 24.0;
                    } else {
                        newNpc->shadowScale = 1.0f;
                    }
                    if (enemy->flags & ENEMY_FLAG_IGNORE_WORLD_COLLISION) {
                        newNpc->flags |= NPC_FLAG_IGNORE_WORLD_COLLISION;
                    }
                    if (enemy->flags & ENEMY_FLAG_IGNORE_PLAYER_COLLISION) {
                        newNpc->flags |= NPC_FLAG_IGNORE_PLAYER_COLLISION;
                    }
                    if (enemy->flags & ENEMY_FLAG_IGNORE_ENTITY_COLLISION) {
                        newNpc->flags |= NPC_FLAG_IGNORE_ENTITY_COLLISION;
                    }
                    if (enemy->flags & ENEMY_FLAG_FLYING) {
                        newNpc->flags |= NPC_FLAG_FLYING;
                    }
                    if (enemy->flags & ENEMY_FLAG_GRAVITY) {
                        newNpc->flags |= NPC_FLAG_GRAVITY;
                    }
                    if (!(enemy->flags & ENEMY_FLAG_PASSIVE)) {
                        newNpc->flags |= NPC_FLAG_IGNORE_PLAYER_COLLISION;
                    }
                    if (enemy->flags & ENEMY_FLAG_HAS_NO_SPRITE) {
                        newNpc->flags |= NPC_FLAG_HAS_NO_SPRITE;
                    }
                    if (enemy->flags & ENEMY_FLAG_NO_SHADOW_RAYCAST) {
                        newNpc->flags |= NPC_FLAG_NO_SHADOW_RAYCAST;
                    }
                    if (enemy->flags & ENEMY_FLAG_USE_INSPECT_ICON) {
                        newNpc->flags |= NPC_FLAG_USE_INSPECT_ICON;
                    }
                    if (enemy->flags & ENEMY_FLAG_RAYCAST_TO_INTERACT) {
                        newNpc->flags |= NPC_FLAG_RAYCAST_TO_INTERACT;
                    }
                    if (enemy->flags & ENEMY_FLAG_DONT_UPDATE_SHADOW_Y) {
                        newNpc->flags |= NPC_FLAG_DONT_UPDATE_SHADOW_Y;
                    }
                    enemy->scriptGroup = EVT_GROUP_HOSTILE_NPC;
                    if (enemy->flags & ENEMY_FLAG_PASSIVE) {
                        enemy->scriptGroup = EVT_GROUP_PASSIVE_NPC;
                    }
                    if (npcSettings->otherAI != NULL) {
                        script = start_script(npcSettings->otherAI, EVT_PRIORITY_A, 0);
                        enemy->aiScript = script;
                        enemy->aiScriptID = script->id;
                        script->owner1.enemy = enemy;
                        script->owner2.npcID = enemy->npcID;
                        script->groupFlags = enemy->scriptGroup;
                    }
 
                    npcData++;
                }
                groupList++;
                e++;
                totalNpcCount += groupNpcCount;
            }
            currentEncounter->numEncounters = e;
            gEncounterSubState = ENCOUNTER_SUBSTATE_CREATE_RUN_INIT_SCRIPT;
            break;
 
        case ENCOUNTER_SUBSTATE_CREATE_RUN_INIT_SCRIPT:
            cond2 = FALSE;
            for (e = 0; e < currentEncounter->numEncounters; e++) {
                encounter = currentEncounter->encounterList[e];
                if (encounter == NULL) {
                    continue;
                }
                for (i = 0; i < encounter->count; i++) {
                    enemy = encounter->enemy[i];
                    if (enemy == NULL) {
                        continue;
                    }
                    if (enemy->aiScript != NULL) {
                        if (does_script_exist(enemy->aiScriptID)) {
                            cond2 = TRUE;
                        }
                    }
                }
            }
            if (!cond2) {
                for (e = 0; e < currentEncounter->numEncounters; e++) {
                    encounter = currentEncounter->encounterList[e];
                    if (encounter == NULL) {
                        continue;
                    }
                    for (i = 0; i < encounter->count; i++) {
                        enemy = encounter->enemy[i];
                        if (enemy == NULL) {
                            continue;
                        }
                        if (enemy->initBytecode != NULL) {
                            script = start_script(enemy->initBytecode, EVT_PRIORITY_A, 0);
                            enemy->initScript = script;
                            enemy->initScriptID = script->id;
                            script->owner1.enemy = enemy;
                            script->owner2.npcID = enemy->npcID;
                            script->groupFlags = enemy->scriptGroup;
                        }
                    }
                }
                gEncounterSubState = ENCOUNTER_SUBSTATE_CREATE_RUN_AI;
            }
            break;
 
        case ENCOUNTER_SUBSTATE_CREATE_RUN_AI:
            cond1 = FALSE;
 
            for (e = 0; e < currentEncounter->numEncounters; e++) {
                encounter = currentEncounter->encounterList[e];
                if (encounter == NULL) {
                    continue;
                }
                for (i = 0; i < encounter->count; i++) {
                    enemy = encounter->enemy[i];
                    if (enemy == NULL) {
                        continue;
                    }
                    if (enemy->initScript != NULL) {
                        if (does_script_exist(enemy->initScriptID)) {
                            cond1 = TRUE;
                        } else {
                            enemy->initScript = NULL;
                        }
                    }
                }
            }
 
            if (cond1) {
                break;
            }
 
            for (e = 0; e < currentEncounter->numEncounters; e++) {
                encounter = currentEncounter->encounterList[e];
                if (encounter == NULL) {
                    continue;
                }
                for (i = 0; i < encounter->count; i++) {
                    enemy = encounter->enemy[i];
                    if (enemy == NULL) {
                        continue;
                    }
                    if (!(enemy->flags & ENEMY_FLAG_DISABLE_AI)) {
                        if (enemy->aiBytecode != NULL) {
                            script = start_script(enemy->aiBytecode, EVT_PRIORITY_A, 0);
                            enemy->aiScript = script;
                            enemy->aiScriptID = script->id;
                            enemy->unk_C8 = 100;
                            script->owner1.enemy = enemy;
                            script->owner2.npcID = enemy->npcID;
                            script->groupFlags = enemy->scriptGroup;
                        }
                    }
                }
            }
 
            for (e = 0; e < currentEncounter->numEncounters; e++) {
                encounter = currentEncounter->encounterList[e];
                if (encounter == NULL) {
                    continue;
                }
                for (i = 0; i < encounter->count; i++) {
                    enemy = encounter->enemy[i];
                    if (enemy == NULL) {
                        continue;
                    }
                    if (!(enemy->flags & ENEMY_FLAG_DISABLE_AI)) {
                        if (enemy->auxBytecode != NULL) {
                            script = start_script(enemy->auxBytecode, EVT_PRIORITY_A, 0);
                            enemy->auxScript = script;
                            enemy->auxScriptID = script->id;
                            script->owner1.enemy = enemy;
                            script->owner2.npcID = enemy->npcID;
                            script->groupFlags = enemy->scriptGroup;
                        }
                    }
                }
            }
            resume_all_group(EVT_GROUP_FLAG_BATTLE);
            gEncounterState = ENCOUNTER_STATE_NEUTRAL;
            EncounterStateChanged = TRUE;
            gEncounterSubState = ENCOUNTER_SUBSTATE_NEUTRAL;
            break;
    }
}

Referenced by update_encounters().

◆ update_encounters_neutral()

void update_encounters_neutral ( void )

Definition at line 481 of file encounter.c.

                                     {
    EncounterStatus* currentEncounter = &gCurrentEncounter;
    PlayerStatus* playerStatus = &gPlayerStatus;
    Camera* camera = &gCameras[gCurrentCameraID];
    s32 screenX, screenY, screenZ;
    f32 npcX, npcY, npcZ;
    f32 npcYaw;
    f32 testX, testY, testZ;
    f32 x, y, z;
    s32 e;
    f32 playerX, playerY, playerZ;
    f32 playerYaw;
    Encounter* encounter;
    Evt* script;
    Npc* npc;
    f32 distance;
    f32 colHeight;
    f32 colRadius;
    f32 hammerDir;
 
    s32 triggeredBattle;
    s32 cond2;
    s32 firstStrikeType;
    s32 suspendTime;
 
    Enemy* enemy;
    Enemy* currentEnemy;
    s32 i;
 
    f32 playerJumpColHeight = 37.0f;
    f32 playerColRadius = 14.0f;
    f32 playerColHeight = 18.0f;
 
    f32 dx, dz;
    f32 angle1, angle2;
 
    if (currentEncounter->hitType == ENCOUNTER_TRIGGER_CONVERSATION) {
        goto START_BATTLE;
    }
 
    currentEncounter->songID = -1;
    currentEncounter->unk_18 = -1;
    currentEncounter->hitType = 0;
    currentEncounter->forbidFleeing = FALSE;
    currentEncounter->dropWhackaBump = FALSE;
    currentEncounter->flags &= ~ENCOUNTER_FLAG_THUMBS_UP;
    currentEncounter->flags &= ~ENCOUNTER_FLAG_CANT_SKIP_WIN_DELAY;
    currentEncounter->flags &= ~ENCOUNTER_FLAG_SKIP_FLEE_DROPS;
 
    playerX = playerStatus->pos.x;
    playerY = playerStatus->pos.y;
    playerZ = playerStatus->pos.z;
    playerYaw = playerStatus->spriteFacingAngle;
 
    if (playerYaw < 180.0f) {
        playerYaw = clamp_angle(camera->curYaw - 90.0f);
    } else {
        playerYaw = clamp_angle(camera->curYaw + 90.0f);
    }
 
    if (currentEncounter->battleTriggerCooldown != 0) {
        if (!(gOverrideFlags & GLOBAL_OVERRIDES_40)) {
            currentEncounter->battleTriggerCooldown--;
        }
        if (playerStatus->blinkTimer != 0) {
            if (!(playerStatus->flags & PS_FLAG_INPUT_DISABLED)) {
                playerStatus->blinkTimer = currentEncounter->battleTriggerCooldown;
            } else {
                playerStatus->blinkTimer = 1;
            }
        }
    }
 
    for (e = 0; e < currentEncounter->numEncounters; e++) {
        encounter = currentEncounter->encounterList[e];
        if (encounter == NULL) {
            continue;
        }
        for (i = 0; i < encounter->count; i++) {
            enemy = encounter->enemy[i];
            if (enemy == NULL || (enemy->flags & ENEMY_FLAG_DISABLE_AI)) {
                continue;
            }
            npc = get_npc_unsafe(enemy->npcID);
            if (enemy->aiSuspendTime != 0) {
                if (!(gOverrideFlags & GLOBAL_OVERRIDES_40)) {
                    enemy->aiSuspendTime--;
                    suspendTime = enemy->aiSuspendTime;
                } else {
                    suspendTime = 0;
                }
 
                if (suspendTime & 1) {
                    npc->flags |= NPC_FLAG_SUSPENDED;
                    enemy->flags |= ENEMY_FLAG_SUSPENDED;
                } else {
                    npc->flags &= ~NPC_FLAG_SUSPENDED;
                    enemy->flags &= ~ENEMY_FLAG_SUSPENDED;
                }
 
                script = get_script_by_id(enemy->auxScriptID);
                if (script != NULL) {
                    set_script_flags(script, EVT_FLAG_SUSPENDED);
                }
                script = get_script_by_id(enemy->aiScriptID);
                if (script != NULL) {
                    set_script_flags(script, EVT_FLAG_SUSPENDED);
                }
 
                if (enemy->flags & ENEMY_FLAG_DONT_SUSPEND_SCRIPTS) {
                    script = get_script_by_id(enemy->auxScriptID);
                    if (script != NULL) {
                        clear_script_flags(script, EVT_FLAG_SUSPENDED);
                    }
                    script = get_script_by_id(enemy->aiScriptID);
                    if (script != NULL) {
                        clear_script_flags(script, EVT_FLAG_SUSPENDED);
                    }
                }
            } else if (!(enemy->flags & ENEMY_FLAG_ACTIVE_WHILE_OFFSCREEN)) {
                get_screen_coords(gCurrentCameraID, npc->pos.x, npc->pos.y, npc->pos.z, &screenX, &screenY, &screenZ);
                if ((screenX < -160 || screenX > 480 || screenY < -120 || screenY > 360 || screenZ < 0) && !(enemy->flags & ENEMY_FLAG_PASSIVE)) {
                    npc->flags |= NPC_FLAG_SUSPENDED;
                    enemy->flags |= ENEMY_FLAG_SUSPENDED;
                    script = get_script_by_id(enemy->auxScriptID);
                    if (script != NULL) {
                        set_script_flags(script, EVT_FLAG_SUSPENDED);
                    }
                    script = get_script_by_id(enemy->aiScriptID);
                    if (script != NULL) {
                        set_script_flags(script, EVT_FLAG_SUSPENDED);
                    }
                } else {
                    npc->flags &= ~NPC_FLAG_SUSPENDED;
                    enemy->flags &= ~ENEMY_FLAG_SUSPENDED;
                    script = get_script_by_id(enemy->auxScriptID);
                    if (script != NULL) {
                        clear_script_flags(script, EVT_FLAG_SUSPENDED);
                    }
                    script = get_script_by_id(enemy->aiScriptID);
                    if (script != NULL) {
                        clear_script_flags(script, EVT_FLAG_SUSPENDED);
                    }
                }
            } else {
                npc->flags &= ~NPC_FLAG_SUSPENDED;
                enemy->flags &= ~ENEMY_FLAG_SUSPENDED;
                script = get_script_by_id(enemy->auxScriptID);
                if (script != NULL) {
                    clear_script_flags(script, EVT_FLAG_SUSPENDED);
                }
                script = get_script_by_id(enemy->aiScriptID);
                if (script != NULL) {
                    clear_script_flags(script, EVT_FLAG_SUSPENDED);
                }
            }
 
            if (enemy->flags & ENEMY_FLAG_SUSPENDED) {
                continue;
            }
            if (enemy->flags & ENEMY_FLAG_PASSIVE) {
                if (!(enemy->flags & ENEMY_FLAG_DO_NOT_AUTO_FACE_PLAYER)) {
                    if (npc == playerStatus->encounteredNPC) {
                        enemy->savedNpcYaw = npc->yaw;
                        npc->yaw = atan2(npc->pos.x, npc->pos.z, playerStatus->pos.x, playerStatus->pos.z);
                        script = get_script_by_id(enemy->aiScriptID);
                        if (script != NULL) {
                            set_script_flags(script, EVT_FLAG_SUSPENDED);
                        }
                    } else {
                        if (enemy->savedNpcYaw != 12345) {
                            npc->yaw = enemy->savedNpcYaw;
                            enemy->savedNpcYaw = 12345;
                        }
                        script = get_script_by_id(enemy->aiScriptID);
                        if (script != NULL) {
                            clear_script_flags(script, EVT_FLAG_SUSPENDED);
                        }
                    }
                } else {
                    script = get_script_by_id(enemy->aiScriptID);
                    if (script != NULL) {
                        clear_script_flags(script, EVT_FLAG_SUSPENDED);
                    }
                }
            }
 
            if (currentEncounter->battleTriggerCooldown != 0
                || gGameStatusPtr->debugEnemyContact == DEBUG_CONTACT_CANT_TOUCH
                || (playerStatus->flags & PS_FLAG_ARMS_RAISED)
                || (gOverrideFlags & GLOBAL_OVERRIDES_40)
                || gPartnerStatus.actingPartner == PARTNER_BOW
                || (enemy->flags & ENEMY_FLAG_PASSIVE)
                || (gOverrideFlags & (GLOBAL_OVERRIDES_DISABLE_BATTLES | GLOBAL_OVERRIDES_200 | GLOBAL_OVERRIDES_400 | GLOBAL_OVERRIDES_800))
                || is_picking_up_item()
            ) {
                continue;
            }
 
            if (!(enemy->flags & ENEMY_FLAG_IGNORE_PARTNER) && partner_test_enemy_collision(npc)) {
                currentEncounter->hitType = ENCOUNTER_TRIGGER_PARTNER;
                enemy->encountered = ENCOUNTER_TRIGGER_PARTNER;
                currentEncounter->curEncounter = encounter;
                currentEncounter->curEnemy = enemy;
                currentEncounter->firstStrikeType = FIRST_STRIKE_PLAYER;
                goto START_BATTLE;
            }
 
            npcX = npc->pos.x;
            npcY = npc->pos.y;
            npcZ = npc->pos.z;
            npcYaw = npc->yaw;
            colHeight = npc->collisionHeight;
            colRadius = npc->collisionDiameter / 2;
 
            if (enemy->unk_DC != 0) {
                npcYaw = npc->yawCamOffset;
                if (npcYaw < 180.0f) {
                    npcYaw = clamp_angle(camera->curYaw - 90.0f);
                } else {
                    npcYaw = clamp_angle(camera->curYaw + 90.0f);
                }
 
                add_vec2D_polar(&npcX, &npcZ, enemy->unk_DC, npcYaw);
            }
 
            dx = npcX - playerX;
            dz = npcZ - playerZ;
            distance = sqrtf(SQ(dx) + SQ(dz));
 
            switch (playerStatus->actionState) {
                case ACTION_STATE_HAMMER:
                    x = playerX;
                    y = playerY;
                    z = playerZ;
                    if (clamp_angle(playerStatus->spriteFacingAngle) < 180.0f) {
                        hammerDir = clamp_angle(camera->curYaw - 90.0f);
                        if (playerStatus->trueAnimation & SPRITE_ID_BACK_FACING) {
                            hammerDir = clamp_angle(hammerDir + 30.0f);
                        }
                    } else {
                        hammerDir = clamp_angle(camera->curYaw + 90.0f);
                        if (playerStatus->trueAnimation & SPRITE_ID_BACK_FACING) {
                            hammerDir = clamp_angle(hammerDir - 30.0f);
                        }
                    }
                    add_vec2D_polar(&x, &z, 24.0f, hammerDir);
                    dx = npcX - x;
                    dz = npcZ - z;
                    distance = sqrtf(SQ(dx) + SQ(dz));
                    if (enemy->flags & ENEMY_FLAG_IGNORE_HAMMER) {
                        break;
                    }
                    if (!(playerStatus->flags & PS_FLAG_HAMMER_CHECK)) {
                        break;
                    }
                    if (distance >= playerColRadius + colRadius || y > npcY + colHeight || npcY > y + playerColHeight) {
                        break;
                    }
 
                    testX = npcX;
                    testY = npcY;
                    testZ = npcZ;
 
                    if (npc_test_move_taller_with_slipping(COLLIDER_FLAG_IGNORE_PLAYER, &testX, &testY, &testZ, distance, atan2(npcX, npcZ, playerX, playerZ), colHeight, colRadius * 2.0f)) {
                        testX = playerX;
                        testY = playerY;
                        testZ = playerZ;
                        if (npc_test_move_taller_with_slipping(COLLIDER_FLAG_IGNORE_PLAYER, &testX, &testY, &testZ, distance, atan2(playerX, playerZ, npcX, npcZ), colHeight, colRadius * 2.0f)) {
                            break;
                        }
                    }
                    if (enemy->hitboxIsActive) {
                        npcX = enemy->unk_10.x;
                        npcY = enemy->unk_10.y;
                        npcZ = enemy->unk_10.z;
                    }
 
                    angle1 = fabsf(get_clamped_angle_diff(atan2(playerX, playerZ, npcX, npcZ), playerYaw));
                    angle2 = fabsf(get_clamped_angle_diff(atan2(npcX, npcZ, playerX, playerZ), npcYaw));
                    triggeredBattle = FALSE;
                    if (angle1 >= 90.0f && angle2 >= 90.0f) {
                        triggeredBattle = FALSE;
                    }
                    if (angle1 < 90.0f && angle2 >= 90.0f) {
                        triggeredBattle = TRUE;
                    }
                    if (angle1 >= 90.0f && angle2 < 90.0f) {
                        triggeredBattle = FALSE;
                    }
                    if (angle1 < 90.0f && angle2 < 90.0f) {
                        triggeredBattle = TRUE;
                    }
                    if (triggeredBattle) {
                        sfx_play_sound_at_position(SOUND_HIT_PLAYER_NORMAL, SOUND_SPACE_DEFAULT, playerStatus->pos.x, playerStatus->pos.y, playerStatus->pos.z);
                        currentEncounter->hitType = ENCOUNTER_TRIGGER_HAMMER;
                        currentEncounter->hitTier = gPlayerData.hammerLevel;
                        enemy->encountered = ENCOUNTER_TRIGGER_HAMMER;
                        currentEncounter->curEncounter = encounter;
                        currentEncounter->curEnemy = enemy;
                        currentEncounter->firstStrikeType = FIRST_STRIKE_PLAYER;
                        goto START_BATTLE;
                    }
                    break;
                case ACTION_STATE_JUMP:
                case ACTION_STATE_BOUNCE:
                case ACTION_STATE_FALLING:
                case ACTION_STATE_STEP_DOWN:
                case ACTION_STATE_LAND:
                case ACTION_STATE_STEP_DOWN_LAND:
                case ACTION_STATE_SPIN_JUMP:
                case ACTION_STATE_SPIN_POUND:
                case ACTION_STATE_TORNADO_JUMP:
                case ACTION_STATE_TORNADO_POUND:
                    x = playerX;
                    z = playerZ;
                    if (!(enemy->flags & ENEMY_FLAG_IGNORE_JUMP)) {
                        if (distance >= playerColRadius + colRadius) {
                            continue;
                        }
                        if (playerY > npcY + colHeight || npcY > playerY + playerJumpColHeight) {
                            continue;
                        }
 
                        testX = npcX;
                        testY = npcY;
                        testZ = npcZ;
                        if (npc_test_move_taller_with_slipping(COLLIDER_FLAG_IGNORE_PLAYER, &testX, &testY, &testZ, distance, atan2(npcX, npcZ, playerX, playerZ), colHeight, colRadius * 2.0f)) {
                            testX = playerX;
                            testY = playerY;
                            testZ = playerZ;
                            if (npc_test_move_taller_with_slipping(COLLIDER_FLAG_IGNORE_PLAYER, &testX, &testY, &testZ, distance, atan2(playerX, playerZ, npcX, npcZ), colHeight, colRadius * 2.0f)) {
                                break;
                            }
                        }
                        triggeredBattle = FALSE;
                        if (npcY + colHeight < playerY + playerJumpColHeight * 0.5f) {
                            if (playerStatus->actionState == ACTION_STATE_FALLING ||
                                playerStatus->actionState == ACTION_STATE_STEP_DOWN ||
                                playerStatus->actionState == ACTION_STATE_LAND ||
                                playerStatus->actionState == ACTION_STATE_STEP_DOWN_LAND ||
                                playerStatus->actionState == ACTION_STATE_SPIN_JUMP ||
                                playerStatus->actionState == ACTION_STATE_SPIN_POUND ||
                                playerStatus->actionState == ACTION_STATE_TORNADO_JUMP ||
                                playerStatus->actionState == ACTION_STATE_TORNADO_POUND) {
                                triggeredBattle = TRUE;
                            }
                        }
                        if (playerY + playerJumpColHeight < npcY + colHeight * 0.5f) {
                            triggeredBattle = FALSE;
                        }
                        if (triggeredBattle) {
                            if (gPlayerData.bootsLevel < 0) {
                                currentEncounter->hitType = ENCOUNTER_TRIGGER_NONE;
                                enemy->encountered = ENCOUNTER_TRIGGER_NONE;
                                currentEncounter->curEncounter = encounter;
                                currentEncounter->curEnemy = enemy;
                                currentEncounter->firstStrikeType = FIRST_STRIKE_NONE;
                                currentEncounter->hitTier = 0;
                                goto START_BATTLE;
                            }
                            currentEncounter->hitType = ENCOUNTER_TRIGGER_JUMP;
                            switch (playerStatus->actionState) {
                                case ACTION_STATE_JUMP:
                                case ACTION_STATE_BOUNCE:
                                case ACTION_STATE_FALLING:
                                case ACTION_STATE_STEP_DOWN:
                                case ACTION_STATE_LAND:
                                case ACTION_STATE_STEP_DOWN_LAND:
                                    currentEncounter->hitTier = 0;
                                    break;
                                case ACTION_STATE_SPIN_JUMP:
                                case ACTION_STATE_SPIN_POUND:
                                    currentEncounter->hitTier = 1;
                                    break;
                                case ACTION_STATE_TORNADO_JUMP:
                                case ACTION_STATE_TORNADO_POUND:
                                    currentEncounter->hitTier = 2;
                                    break;
                            }
                            sfx_play_sound_at_position(SOUND_HIT_PLAYER_NORMAL, SOUND_SPACE_DEFAULT, playerStatus->pos.x, playerStatus->pos.y, playerStatus->pos.z);
                            enemy->encountered = ENCOUNTER_STATE_NEUTRAL;
                            currentEncounter->curEncounter = encounter;
                            currentEncounter->curEnemy = enemy;
                            currentEncounter->firstStrikeType = FIRST_STRIKE_PLAYER;
                            goto START_BATTLE;
                        }
                    }
                    break;
            }
 
            if (enemy->flags & ENEMY_FLAG_IGNORE_TOUCH) {
                continue;
            }
 
            dx = npcX - playerX;
            dz = npcZ - playerZ;
            distance = sqrtf(SQ(dx) + SQ(dz));
 
            if (distance >= (playerColRadius + colRadius) * 0.8) {
                continue;
            }
            if (npcY + colHeight < playerY) {
                continue;
            }
            if (playerY + playerJumpColHeight < npcY) {
                continue;
            }
 
            testX = npcX;
            testY = npcY;
            testZ = npcZ;
            if (npc_test_move_taller_with_slipping(COLLIDER_FLAG_IGNORE_PLAYER, &testX, &testY, &testZ, distance, atan2(npcX, npcZ, playerX, playerZ), colHeight, colRadius * 2.0f)) {
                testX = playerX;
                testY = playerY;
                testZ = playerZ;
                if (npc_test_move_taller_with_slipping(COLLIDER_FLAG_IGNORE_PLAYER, &testX, &testY, &testZ, distance, atan2(playerX, playerZ, npcX, npcZ), colHeight, colRadius * 2.0f)) {
                    continue;
                }
            }
            triggeredBattle = FALSE;
            if (is_ability_active(ABILITY_SPIN_ATTACK) && gPlayerData.level >= enemy->npcSettings->level) {
                triggeredBattle = !currentEncounter->scriptedBattle;
            }
            if (is_ability_active(ABILITY_DIZZY_ATTACK)) {
                triggeredBattle = TRUE;
            }
            if ((playerStatus->animFlags & PA_FLAG_SPINNING) && !(enemy->flags & ENEMY_FLAG_IGNORE_SPIN) && triggeredBattle) {
                sfx_play_sound_at_position(SOUND_HIT_PLAYER_NORMAL, SOUND_SPACE_DEFAULT, playerStatus->pos.x, playerStatus->pos.y, playerStatus->pos.z);
                testX = playerStatus->pos.x + ((npc->pos.x - playerStatus->pos.x) * 0.5f);
                testY = playerStatus->pos.y + (((npc->pos.y + npc->collisionHeight) - (playerStatus->pos.y + playerStatus->colliderHeight)) * 0.5f);
                testZ = playerStatus->pos.z + ((npc->pos.z - playerStatus->pos.z) * 0.5f);
                fx_damage_stars(FX_DAMAGE_STARS_3, testX, testY, testZ, 0.0f, -1.0f, 0.0f, 3);
                currentEncounter->hitType = ENCOUNTER_TRIGGER_SPIN;
                playerStatus->animFlags |= PA_FLAG_DIZZY_ATTACK_ENCOUNTER;
                enemy->encountered = ENCOUNTER_TRIGGER_SPIN;
                currentEncounter->curEncounter = encounter;
                currentEncounter->curEnemy = enemy;
                currentEncounter->firstStrikeType = FIRST_STRIKE_NONE;
            } else {
                currentEncounter->hitType = ENCOUNTER_TRIGGER_NONE;
                playerStatus->animFlags &= ~PA_FLAG_DIZZY_ATTACK_ENCOUNTER;
                enemy->encountered = ENCOUNTER_TRIGGER_NONE;
                currentEncounter->curEncounter = encounter;
                currentEncounter->curEnemy = enemy;
                testX = playerStatus->pos.x + ((npc->pos.x - playerStatus->pos.x) * 0.5f);
                testY = playerStatus->pos.y + (((npc->pos.y + npc->collisionHeight) - (playerStatus->pos.y + playerStatus->colliderHeight)) * 0.5f);
                testZ = playerStatus->pos.z + ((npc->pos.z - playerStatus->pos.z) * 0.5f);
                fx_damage_stars(FX_DAMAGE_STARS_3, testX, testY, testZ, 0.0f, -1.0f, 0.0f, 3);
                // if the hitbox is active, trigger a first strike
                firstStrikeType = FIRST_STRIKE_NONE;
                if (enemy->hitboxIsActive) {
                    if (is_ability_active(ABILITY_CHILL_OUT)) {
                        firstStrikeType = FIRST_STRIKE_NONE;
                    } else {
                        firstStrikeType = FIRST_STRIKE_ENEMY;
                    }
                }
                // cancel the first strike if bump attack is applicable
                if ((is_ability_active(ABILITY_BUMP_ATTACK)
                        && (gPlayerData.level >= enemy->npcSettings->level)
                        && !(enemy->flags & ENEMY_FLAG_PROJECTILE))
                    && !currentEncounter->scriptedBattle
                ) {
                    firstStrikeType = FIRST_STRIKE_NONE;
                }
                currentEncounter->firstStrikeType = firstStrikeType;
            }
            goto START_BATTLE;
        }
    }
 
START_BATTLE:
    switch (currentEncounter->hitType) {
        case 0:
            break;
        case ENCOUNTER_TRIGGER_NONE:
            currentEnemy = enemy = currentEncounter->curEnemy;
            if (enemy->aiScript != NULL) {
                suspend_all_script(enemy->aiScriptID);
            }
            if (enemy->auxScript != NULL) {
                suspend_all_script(enemy->auxScriptID);
            }
            encounter = currentEncounter->curEncounter;
            for (i = 0; i < encounter->count; i++) {
                enemy = encounter->enemy[i];
                if (enemy == NULL) {
                    continue;
                }
                if ((enemy->flags & ENEMY_FLAG_ENABLE_HIT_SCRIPT) && enemy != currentEncounter->curEnemy) {
                    continue;
                }
                if (enemy->flags & ENEMY_FLAG_DISABLE_AI) {
                    continue;
                }
                if ((currentEnemy->flags & ENEMY_FLAG_PROJECTILE) && enemy != currentEncounter->curEnemy) {
                    continue;
                }
 
                if (enemy->hitBytecode != NULL) {
                    enemy->encountered = ENCOUNTER_TRIGGER_NONE;
                    script = start_script(enemy->hitBytecode, EVT_PRIORITY_A, 0);
                    enemy->hitScript = script;
                    enemy->hitScriptID = script->id;
                    script->owner1.enemy = enemy;
                    script->owner2.npcID = enemy->npcID;
                    script->groupFlags = enemy->scriptGroup;
                }
            }
            disable_player_input();
            partner_disable_input();
            if (playerStatus->actionState != ACTION_STATE_TORNADO_JUMP &&
                playerStatus->actionState != ACTION_STATE_TORNADO_POUND &&
                playerStatus->actionState != ACTION_STATE_SPIN_JUMP &&
                playerStatus->actionState != ACTION_STATE_SPIN_POUND) {
                playerStatus->flags |= PS_FLAG_ENTERING_BATTLE;
            }
            if (!is_ability_active(ABILITY_CHILL_OUT) && currentEncounter->firstStrikeType == FIRST_STRIKE_ENEMY) {
                set_action_state(ACTION_STATE_ENEMY_FIRST_STRIKE);
                npc = get_npc_unsafe(enemy->npcID);
                sfx_play_sound_at_position(SOUND_HIT_PLAYER_NORMAL, SOUND_SPACE_DEFAULT, npc->pos.x, npc->pos.y, npc->pos.z);
            }
            currentEncounter->scriptedBattle = FALSE;
            currentEncounter->fadeOutAmount = 0;
            currentEncounter->substateDelay = 0;
            gEncounterState = ENCOUNTER_STATE_PRE_BATTLE;
            EncounterStateChanged = TRUE;
            gEncounterSubState = ENCOUNTER_SUBSTATE_PRE_BATTLE_INIT;
            break;
        case ENCOUNTER_TRIGGER_SPIN:
            currentEnemy = enemy = currentEncounter->curEnemy;
            if (enemy->aiScript != NULL) {
                suspend_all_script(enemy->aiScriptID);
            }
            if (enemy->auxScript != NULL) {
                suspend_all_script(enemy->auxScriptID);
            }
            encounter = currentEncounter->curEncounter;
            for (i = 0; i < encounter->count; i++) {
                enemy = encounter->enemy[i];
                if (enemy == NULL) {
                    continue;
                }
                if ((enemy->flags & ENEMY_FLAG_ENABLE_HIT_SCRIPT) && enemy != currentEncounter->curEnemy) {
                    continue;
                }
                if (enemy->flags & ENEMY_FLAG_DISABLE_AI) {
                    continue;
                }
                if ((currentEnemy->flags & ENEMY_FLAG_PROJECTILE) && enemy != currentEncounter->curEnemy) {
                    continue;
                }
 
                if (enemy->hitBytecode != NULL) {
                    enemy->encountered = ENCOUNTER_TRIGGER_SPIN;
                    script = start_script(enemy->hitBytecode, EVT_PRIORITY_A, 0);
                    enemy->hitScript = script;
                    enemy->hitScriptID = script->id;
                    script->owner1.enemy = enemy;
                    script->owner2.npcID = enemy->npcID;
                    script->groupFlags = enemy->scriptGroup;
                }
            }
            disable_player_input();
            partner_disable_input();
            currentEncounter->scriptedBattle = FALSE;
            currentEncounter->fadeOutAmount = 0;
            currentEncounter->substateDelay = 0;
            gEncounterState = ENCOUNTER_STATE_PRE_BATTLE;
            EncounterStateChanged = TRUE;
            gEncounterSubState = ENCOUNTER_SUBSTATE_PRE_BATTLE_INIT;
            playerStatus->flags |= PS_FLAG_ENTERING_BATTLE;
            break;
        case ENCOUNTER_TRIGGER_JUMP:
            currentEnemy = enemy = currentEncounter->curEnemy;
            if (enemy->aiScript != NULL) {
                suspend_all_script(enemy->aiScriptID);
            }
            if (enemy->auxScript != NULL) {
                suspend_all_script(enemy->auxScriptID);
            }
            encounter = currentEncounter->curEncounter;
 
            cond2 = FALSE;
            for (i = 0; i < encounter->count; i++) {
                enemy = encounter->enemy[i];
                enemy = encounter->enemy[i];
                if (enemy == NULL) {
                    continue;
                }
                if ((enemy->flags & ENEMY_FLAG_ENABLE_HIT_SCRIPT) && enemy != currentEncounter->curEnemy) {
                    continue;
                }
                if (enemy->flags & ENEMY_FLAG_DISABLE_AI) {
                    continue;
                }
                if ((currentEnemy->flags & ENEMY_FLAG_PROJECTILE) && enemy != currentEncounter->curEnemy) {
                    continue;
                }
                if (enemy->hitBytecode != NULL) {
                    enemy->encountered = ENCOUNTER_TRIGGER_JUMP;
                    script = start_script(enemy->hitBytecode, EVT_PRIORITY_A, 0);
                    enemy->hitScript = script;
                    enemy->hitScriptID = script->id;
                    script->owner1.enemy = enemy;
                    script->owner2.npcID = enemy->npcID;
                    script->groupFlags = enemy->scriptGroup;
                    npc = get_npc_unsafe(enemy->npcID);
                    cond2 = TRUE;
                    testX =  playerStatus->pos.x + ((npc->pos.x - playerStatus->pos.x) * 0.5f);
                    testY = playerStatus->pos.y + (((npc->pos.y + npc->collisionHeight) - (playerStatus->pos.y + playerStatus->colliderHeight)) * 0.5f);
                    testZ = playerStatus->pos.z + ((npc->pos.z - playerStatus->pos.z) * 0.5f);
                    fx_damage_stars(FX_DAMAGE_STARS_3, testX, testY, testZ, 0.0f, -1.0f, 0.0f, 3);
                } else if (!(enemy->flags & ENEMY_FLAG_PASSIVE)) {
                    npc = get_npc_unsafe(enemy->npcID);
                    cond2 = TRUE;
                    testX =  playerStatus->pos.x + ((npc->pos.x - playerStatus->pos.x) * 0.5f);
                    testY = playerStatus->pos.y + (((npc->pos.y + npc->collisionHeight) - (playerStatus->pos.y + playerStatus->colliderHeight)) * 0.5f);
                    testZ = playerStatus->pos.z + ((npc->pos.z - playerStatus->pos.z) * 0.5f);
                    fx_damage_stars(FX_DAMAGE_STARS_3, testX, testY, testZ, 0.0f, -1.0f, 0.0f, 3);
                }
            }
            disable_player_input();
            partner_disable_input();
            playerStatus->flags |= PS_FLAG_ENTERING_BATTLE;
            if (cond2) {
                start_bounce_a();
            }
            currentEncounter->fadeOutAmount = 0;
            currentEncounter->substateDelay = 0;
            currentEncounter->scriptedBattle = FALSE;
            sfx_play_sound(SOUND_NONE);
            gEncounterState = ENCOUNTER_STATE_PRE_BATTLE;
            EncounterStateChanged = TRUE;
            gEncounterSubState = ENCOUNTER_SUBSTATE_PRE_BATTLE_INIT;
            break;
        case ENCOUNTER_TRIGGER_HAMMER:
            currentEnemy = enemy = currentEncounter->curEnemy;
            if (enemy->aiScript != NULL) {
                suspend_all_script(enemy->aiScriptID);
            }
            if (enemy->auxScript != NULL) {
                suspend_all_script(enemy->auxScriptID);
            }
            encounter = currentEncounter->curEncounter;
            for (i = 0; i < encounter->count; i++) {
                enemy = encounter->enemy[i];
                if (enemy == NULL) {
                    continue;
                }
                if ((enemy->flags & ENEMY_FLAG_ENABLE_HIT_SCRIPT) && enemy != currentEncounter->curEnemy) {
                    continue;
                }
                if (enemy->flags & ENEMY_FLAG_DISABLE_AI) {
                    continue;
                }
                if ((currentEnemy->flags & ENEMY_FLAG_PROJECTILE) && enemy != currentEncounter->curEnemy) {
                    continue;
                }
                if (enemy->hitBytecode != NULL) {
                    enemy->encountered = ENCOUNTER_TRIGGER_HAMMER;
                    script = start_script(enemy->hitBytecode, EVT_PRIORITY_A, 0);
                    enemy->hitScript = script;
                    enemy->hitScriptID = script->id;
                    script->owner1.enemy = enemy;
                    script->owner2.npcID = enemy->npcID;
                    script->groupFlags = enemy->scriptGroup;
                    npc = get_npc_unsafe(enemy->npcID);
                    testX =  playerStatus->pos.x + ((npc->pos.x - playerStatus->pos.x) * 0.5f);
                    testY = playerStatus->pos.y + (((npc->pos.y + npc->collisionHeight) - (playerStatus->pos.y + playerStatus->colliderHeight)) * 0.5f);
                    testZ = playerStatus->pos.z + ((npc->pos.z - playerStatus->pos.z) * 0.5f);
                    fx_damage_stars(FX_DAMAGE_STARS_3, testX, testY, testZ, 0.0f, -1.0f, 0.0f, 3);
                } else if (!(enemy->flags & ENEMY_FLAG_PASSIVE)) {
                    npc = get_npc_unsafe(enemy->npcID);
                    testX =  playerStatus->pos.x + ((npc->pos.x - playerStatus->pos.x) * 0.5f);
                    testY = playerStatus->pos.y + (((npc->pos.y + npc->collisionHeight) - (playerStatus->pos.y + playerStatus->colliderHeight)) * 0.5f);
                    testZ = playerStatus->pos.z + ((npc->pos.z - playerStatus->pos.z) * 0.5f);
                    fx_damage_stars(FX_DAMAGE_STARS_3, npc->pos.x, npc->pos.y + npc->collisionHeight, npc->pos.z, 0.0f, -1.0f, 0.0f, 3);
                }
            }
            disable_player_input();
            partner_disable_input();
            currentEncounter->fadeOutAmount = 0;
            currentEncounter->substateDelay = 0;
            currentEncounter->scriptedBattle = FALSE;
            playerStatus->flags |= PS_FLAG_ENTERING_BATTLE;
            sfx_play_sound(SOUND_NONE);
            gEncounterState = ENCOUNTER_STATE_PRE_BATTLE;
            EncounterStateChanged = TRUE;
            gEncounterSubState = ENCOUNTER_SUBSTATE_PRE_BATTLE_INIT;
            break;
        case ENCOUNTER_TRIGGER_CONVERSATION:
            suspend_all_group(EVT_GROUP_FLAG_INTERACT);
            enemy = currentEncounter->curEnemy;
            if (enemy != NULL && enemy->aiScript != NULL) {
                suspend_all_script(enemy->aiScriptID);
            }
            enemy = currentEncounter->curEnemy;
            if (enemy->interactBytecode != NULL) {
                enemy->encountered = ENCOUNTER_TRIGGER_CONVERSATION;
                script = start_script(enemy->interactBytecode, EVT_PRIORITY_A, 0);
                enemy->interactScript = script;
                enemy->interactScriptID = script->id;
                script->owner1.enemy = enemy;
                script->owner2.npcID = enemy->npcID;
                script->groupFlags = enemy->scriptGroup;
            }
            disable_player_input();
            partner_disable_input();
            set_action_state(ACTION_STATE_TALK);
            currentEncounter->fadeOutAmount = 0;
            currentEncounter->substateDelay = 0;
            func_800EF3D4(1);
            gEncounterState = ENCOUNTER_STATE_CONVERSATION;
            EncounterStateChanged = TRUE;
            gEncounterSubState = ENCOUNTER_SUBSTATE_CONVERSATION_INIT;
            break;
        case ENCOUNTER_TRIGGER_PARTNER:
            currentEnemy = enemy = currentEncounter->curEnemy;
            if (enemy->aiScript != NULL) {
                suspend_all_script(enemy->aiScriptID);
            }
            if (enemy->auxScript != NULL) {
                suspend_all_script(enemy->auxScriptID);
            }
            encounter = currentEncounter->curEncounter;
 
            for (i = 0; i < encounter->count; i++) {
                enemy = encounter->enemy[i];
                if (enemy == NULL) {
                    continue;
                }
                if ((enemy->flags & ENEMY_FLAG_ENABLE_HIT_SCRIPT) && enemy != currentEncounter->curEnemy) {
                    continue;
                }
                if (enemy->flags & ENEMY_FLAG_DISABLE_AI) {
                    continue;
                }
                if ((currentEnemy->flags & ENEMY_FLAG_PROJECTILE) && enemy != currentEncounter->curEnemy) {
                    continue;
                }
                if (enemy->hitBytecode != NULL) {
                    enemy->encountered = ENCOUNTER_TRIGGER_PARTNER;
                    script = start_script(enemy->hitBytecode, EVT_PRIORITY_A, 0);
                    enemy->hitScript = script;
                    enemy->hitScriptID = script->id;
                    script->owner1.enemy = enemy;
                    script->owner2.npcID = enemy->npcID;
                    script->groupFlags = enemy->scriptGroup;
                    npc = get_npc_unsafe(enemy->npcID);
                    testX = npc->pos.x;
                    testY = npc->pos.y + npc->collisionHeight;
                    testZ = npc->pos.z;
                    fx_damage_stars(FX_DAMAGE_STARS_3, testX, testY, testZ, 0.0f, -1.0f, 0.0f, 3);
                } else if (!(enemy->flags & ENEMY_FLAG_PASSIVE)) {
                    npc = get_npc_unsafe(enemy->npcID);
                    testX = npc->pos.x;
                    testY = npc->pos.y + npc->collisionHeight;
                    testZ = npc->pos.z;
                    fx_damage_stars(FX_DAMAGE_STARS_3, testX, testY, testZ, 0.0f, -1.0f, 0.0f, 3);
                }
            }
            disable_player_input();
            partner_disable_input();
            currentEncounter->fadeOutAmount = 0;
            currentEncounter->substateDelay = 0;
            currentEncounter->scriptedBattle = FALSE;
            playerStatus->flags |= PS_FLAG_ENTERING_BATTLE;
            sfx_play_sound(SOUND_NONE);
            gEncounterState = ENCOUNTER_STATE_PRE_BATTLE;
            EncounterStateChanged = TRUE;
            gEncounterSubState = ENCOUNTER_SUBSTATE_PRE_BATTLE_INIT;
            break;
    }
}

Referenced by update_encounters().

◆ update_encounters_pre_battle()

void update_encounters_pre_battle ( void )

Definition at line 1261 of file encounter.c.

                                        {
    EncounterStatus* currentEncounter = &gCurrentEncounter;
    PlayerData* playerData = &gPlayerData;
    Encounter* encounter;
    Enemy* enemy;
    s32 i;
    s32 j;
 
    switch (gEncounterSubState) {
        case ENCOUNTER_SUBSTATE_PRE_BATTLE_INIT:
            currentEncounter->fadeOutAmount = 0;
            currentEncounter->substateDelay = 1;
            currentEncounter->fadeOutAccel = 1;
            currentEncounter->unk_08 = -1;
            HasPreBattleSongPushed = FALSE;
            D_80077C40 = FALSE;
            suspend_all_group(EVT_GROUP_FLAG_BATTLE);
 
            // suspend all ai scripts
            for (i = 0; i < currentEncounter->numEncounters; i++) {
                encounter = currentEncounter->encounterList[i];
 
                if (encounter != NULL) {
                    for (j = 0; j < encounter->count; j++) {
                        enemy = encounter->enemy[j];
                        if (enemy != NULL && !(enemy->flags & ENEMY_FLAG_DISABLE_AI)) {
                            if (enemy->aiScript != NULL) {
                                suspend_all_script(enemy->aiScriptID);
                            }
                            if (enemy->auxScript != NULL) {
                                suspend_all_script(enemy->auxScriptID);
                            }
                        }
                    }
                }
            }
 
            // try skip-on-contact
            enemy = currentEncounter->curEnemy;
            if ((enemy->flags & ENEMY_FLAG_SKIP_BATTLE) && !currentEncounter->scriptedBattle) {
                currentEncounter->substateDelay = 0;
                currentEncounter->battleStartCountdown = 0;
                partner_handle_before_battle();
                gEncounterSubState = ENCOUNTER_SUBSTATE_PRE_BATTLE_SKIP;
                return;
            }
 
            // try kill-on-contact
            if (gGameStatusPtr->debugEnemyContact == DEBUG_CONTACT_DIE_ON_TOUCH) {
                currentEncounter->substateDelay = 0;
                currentEncounter->battleStartCountdown = 10;
                partner_handle_before_battle();
                gEncounterSubState = ENCOUNTER_SUBSTATE_PRE_BATTLE_AUTO_WIN;
                return;
            }
 
            // try first attack kill
            enemy = currentEncounter->curEnemy;
            if (currentEncounter->hitType != ENCOUNTER_TRIGGER_NONE
                && currentEncounter->hitType != ENCOUNTER_TRIGGER_SPIN
                && is_ability_active(ABILITY_FIRST_ATTACK)
                && (playerData->level >= enemy->npcSettings->level)
                && !(enemy->flags & ENEMY_FLAG_PROJECTILE)
                && !currentEncounter->scriptedBattle
            ) {
                currentEncounter->substateDelay = 0;
                currentEncounter->battleStartCountdown = 10;
                D_80077C40 = TRUE;
                gEncounterSubState = ENCOUNTER_SUBSTATE_PRE_BATTLE_AUTO_WIN;
                return;
            }
 
            // try bump attack kill
            enemy = currentEncounter->curEnemy;
            if (is_ability_active(ABILITY_BUMP_ATTACK)
                && (playerData->level >= enemy->npcSettings->level)
                && !(enemy->flags & ENEMY_FLAG_PROJECTILE)
                && !(currentEncounter->scriptedBattle)
            ) {
                currentEncounter->substateDelay = 0;
                currentEncounter->battleStartCountdown = 10;
                D_80077C40 = TRUE;
                gEncounterSubState = ENCOUNTER_SUBSTATE_PRE_BATTLE_AUTO_WIN;
                return;
            }
 
            // try spin attack kill
            enemy = currentEncounter->curEnemy;
            if (currentEncounter->hitType == ENCOUNTER_TRIGGER_SPIN
                && is_ability_active(ABILITY_SPIN_ATTACK)
                && playerData->level >= enemy->npcSettings->level
                && !(enemy->flags & ENEMY_FLAG_PROJECTILE)
                && !currentEncounter->scriptedBattle
            ) {
                currentEncounter->substateDelay = 0;
                currentEncounter->battleStartCountdown = 10;
                D_80077C40 = TRUE;
                gEncounterSubState = ENCOUNTER_SUBSTATE_PRE_BATTLE_AUTO_WIN;
                return;
            }
 
            // start battle music
            if (currentEncounter->songID < 0) {
                switch (currentEncounter->firstStrikeType) {
                    case FIRST_STRIKE_NONE:
                        bgm_set_battle_song(SONG_NORMAL_BATTLE, FIRST_STRIKE_NONE);
                        break;
                    case FIRST_STRIKE_PLAYER:
                        bgm_set_battle_song(SONG_NORMAL_BATTLE, FIRST_STRIKE_PLAYER);
                        break;
                    case FIRST_STRIKE_ENEMY:
                        bgm_set_battle_song(SONG_NORMAL_BATTLE, FIRST_STRIKE_ENEMY);
                        break;
                }
            } else {
                bgm_set_battle_song(currentEncounter->songID, FIRST_STRIKE_NONE);
            }
            bgm_push_battle_song();
            HasPreBattleSongPushed = TRUE;
 
            currentEncounter->battleStartCountdown = 10;
            gEncounterSubState = ENCOUNTER_SUBSTATE_PRE_BATTLE_LOAD;
            // fallthrough
        case ENCOUNTER_SUBSTATE_PRE_BATTLE_LOAD:
            // wait for screen to fade out
            if (currentEncounter->fadeOutAmount != 255) {
                break;
            }
            // delay before loading the battle
            if (currentEncounter->battleStartCountdown != 0) {
                currentEncounter->battleStartCountdown--;
                break;
            }
 
            // kill all enemy hit scripts
            encounter = currentEncounter->curEncounter;
            for (i = 0; i < encounter->count; i++) {
                enemy = encounter->enemy[i];
                if (enemy != NULL &&
                    ((!(enemy->flags & ENEMY_FLAG_ENABLE_HIT_SCRIPT) || enemy == currentEncounter->curEnemy)) &&
                    !(enemy->flags & ENEMY_FLAG_DISABLE_AI) &&
                    enemy->hitScript != NULL)
                {
                    kill_script_by_ID(enemy->hitScriptID);
                    enemy->hitScript = NULL;
                }
            }
 
            partner_handle_before_battle();
            currentEncounter->dizzyAttack.status = 0;
            currentEncounter->dizzyAttack.duration = 0;
 
            enemy = currentEncounter->curEnemy;
            currentEncounter->instigatorValue = enemy->instigatorValue;
 
            if (is_ability_active(ABILITY_DIZZY_ATTACK) && currentEncounter->hitType == ENCOUNTER_TRIGGER_SPIN) {
                currentEncounter->dizzyAttack.status = 4;
                currentEncounter->dizzyAttack.duration = 3;
            }
 
            sfx_stop_sound(SOUND_SPIN);
            sfx_stop_sound(SOUND_SPEEDY_SPIN);
            sfx_stop_sound(SOUND_SPIN_ATTACK);
            sfx_stop_sound(SOUND_SPEEDY_SPIN_ATTACK);
            set_battle_formation(NULL);
            set_battle_stage(encounter->stage);
            load_battle(encounter->battle);
            currentEncounter->unk_07 = 1;
            currentEncounter->unk_08 = 0;
            currentEncounter->hasMerleeCoinBonus = FALSE;
            currentEncounter->damageTaken = 0;
            currentEncounter->coinsEarned = 0;
            currentEncounter->fadeOutAccel = 0;
            currentEncounter->fadeOutAmount = 255;
            set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, 255.0f);
 
            // prepare to resume after battle
            gEncounterState = ENCOUNTER_STATE_POST_BATTLE;
            EncounterStateChanged = TRUE;
            gEncounterSubState = ENCOUNTER_SUBSTATE_POST_BATTLE_INIT;
            break;
        case ENCOUNTER_SUBSTATE_PRE_BATTLE_AUTO_WIN:
            if (currentEncounter->battleStartCountdown != 0) {
                currentEncounter->battleStartCountdown--;
                break;
            }
 
            encounter = currentEncounter->curEncounter;
            for (i = 0; i < encounter->count; i++) {
                enemy = encounter->enemy[i];
                if (enemy != NULL &&
                    (!(enemy->flags & ENEMY_FLAG_ENABLE_HIT_SCRIPT) || enemy == currentEncounter->curEnemy) &&
                    !(enemy->flags & ENEMY_FLAG_DISABLE_AI) &&
                    (enemy->hitScript != 0))
                {
                    kill_script_by_ID(enemy->hitScriptID);
                    enemy->hitScript = NULL;
                }
            }
 
            currentEncounter->unk_08 = 1;
            currentEncounter->unk_07 = 1;
            currentEncounter->battleOutcome = OUTCOME_PLAYER_WON;
            currentEncounter->hasMerleeCoinBonus = FALSE;
            currentEncounter->damageTaken = 0;
            currentEncounter->coinsEarned = 0;
 
            currentEncounter->fadeOutAccel = 0;
            currentEncounter->fadeOutAmount = 0;
            gEncounterState = ENCOUNTER_STATE_POST_BATTLE;
            EncounterStateChanged = TRUE;
            gEncounterSubState = ENCOUNTER_SUBSTATE_POST_BATTLE_INIT;
            break;
        case ENCOUNTER_SUBSTATE_PRE_BATTLE_SKIP:
            currentEncounter->battleOutcome = OUTCOME_SKIP;
            currentEncounter->unk_08 = 1;
 
            currentEncounter->fadeOutAmount = 0;
            currentEncounter->fadeOutAccel = 0;
            gEncounterState = ENCOUNTER_STATE_POST_BATTLE;
            EncounterStateChanged = TRUE;
            gEncounterSubState = ENCOUNTER_SUBSTATE_POST_BATTLE_INIT;
            break;
    }
}

Referenced by update_encounters().

◆ update_encounters_conversation()

void update_encounters_conversation ( void )

Definition at line 2263 of file encounter.c.

                                          {
    EncounterStatus* encounter = &gCurrentEncounter;
    PlayerStatus* playerStatus = &gPlayerStatus;
    Enemy* currentEnemy;
    s32 flag;
 
    switch (gEncounterSubState) {
        case ENCOUNTER_SUBSTATE_CONVERSATION_INIT:
            currentEnemy = encounter->curEnemy;
            flag = FALSE;
 
            if (currentEnemy->interactScript != NULL) {
                if (does_script_exist(currentEnemy->interactScriptID)) {
                    flag = TRUE;
                } else {
                    currentEnemy->interactScript = NULL;
                }
            }
 
            if (currentEnemy->hitScript != NULL) {
                if (does_script_exist(currentEnemy->hitScriptID)) {
                    flag = TRUE;
                } else {
                    currentEnemy->hitScript = NULL;
                }
            }
 
            if (!flag) {
                gEncounterSubState = ENCOUNTER_SUBSTATE_CONVERSATION_END;
            }
            break;
        case ENCOUNTER_SUBSTATE_CONVERSATION_END:
            resume_all_group(EVT_GROUP_FLAG_INTERACT);
 
            currentEnemy = encounter->curEnemy;
            if (currentEnemy != NULL && currentEnemy->aiScript != NULL) {
                resume_all_script(currentEnemy->aiScriptID);
            }
 
            enable_player_input();
            partner_enable_input();
 
            if (playerStatus->actionState == ACTION_STATE_TALK) {
                set_action_state(ACTION_STATE_IDLE);
            }
 
            func_800EF3D4(0);
            encounter->hitType = 0;
            resume_all_group(EVT_GROUP_FLAG_BATTLE);
            gEncounterState = ENCOUNTER_STATE_NEUTRAL;
            EncounterStateChanged = TRUE;
            gEncounterSubState = ENCOUNTER_SUBSTATE_NEUTRAL;
            break;
    }
}

Referenced by update_encounters().

◆ update_encounters_post_battle()

void update_encounters_post_battle ( void )

Definition at line 1619 of file encounter.c.

                                         {
    EncounterStatus* currentEncounter = &gCurrentEncounter;
    PlayerStatus* playerStatus = &gPlayerStatus;
    PlayerData* playerData = &gPlayerData;
    PartnerStatus* partnerStatus = &gPartnerStatus;
    Encounter* encounter;
    Evt* script;
    Enemy* enemy;
    s32 i, j;
    s32 hasDefeatScript;
    Npc* npc;
 
    switch (gEncounterSubState) {
        case ENCOUNTER_SUBSTATE_POST_BATTLE_INIT:
            if (currentEncounter->unk_08 == 0) {
                return;
            }
 
            currentEncounter->unk_08 = 0;
            gPlayerStatus.blinkTimer = 0;
            currentEncounter->scriptedBattle = FALSE;
            setup_status_bar_for_world();
            currentEncounter->dizzyAttack.status = 0;
            currentEncounter->unusedAttack1.status = 0;
            currentEncounter->unusedAttack2.status = 0;
            currentEncounter->unusedAttack3.status = 0;
            currentEncounter->dizzyAttack.duration = 0;
            currentEncounter->unusedAttack1.duration = 0;
            currentEncounter->unusedAttack2.duration = 0;
            currentEncounter->unusedAttack3.duration = 0;
            if (HasPreBattleSongPushed == TRUE) {
                bgm_pop_battle_song();
            }
            currentEncounter->fadeOutAccel = 1;
            currentEncounter->battleStartCountdown = 0;
            LastBattleStartedBySpin = FALSE;
            gPlayerStatus.flags &= ~PS_FLAG_ENTERING_BATTLE;
            if (currentEncounter->hitType == ENCOUNTER_TRIGGER_SPIN) {
                LastBattleStartedBySpin = TRUE;
            }
            currentEncounter->hitType = 0;
            if (!D_80077C40) {
                partner_handle_after_battle();
            }
            PendingPartnerAbilityResume = FALSE;
            if (partnerStatus->shouldResumeAbility) {
                PendingPartnerAbilityResume = TRUE;
            } else if (!LastBattleStartedBySpin
                && !(gPlayerStatus.flags & (PS_FLAG_JUMPING | PS_FLAG_FALLING))
                && gPlayerStatus.actionState != ACTION_STATE_RIDE
                && gPlayerStatus.actionState != ACTION_STATE_USE_SPINNING_FLOWER
            ) {
                set_action_state(ACTION_STATE_IDLE);
            }
            switch (currentEncounter->battleOutcome) {
                case OUTCOME_PLAYER_WON:
                    gEncounterSubState = ENCOUNTER_SUBSTATE_POST_BATTLE_WON_CHECK_MERLEE;
                    break;
                case OUTCOME_PLAYER_LOST:
                    gEncounterSubState = ENCOUNTER_SUBSTATE_POST_BATTLE_LOST_INIT;
                    break;
                case OUTCOME_PLAYER_FLED:
                    gEncounterSubState = ENCOUNTER_SUBSTATE_POST_BATTLE_FLED_INIT;
                    break;
                case OUTCOME_SKIP:
                    gEncounterSubState = ENCOUNTER_SUBSTATE_POST_BATTLE_SKIP;
                    break;
                case OUTCOME_ENEMY_FLED:
                    gEncounterSubState = ENCOUNTER_SUBSTATE_POST_BATTLE_ENEMY_FLED_INIT;
                    break;
            }
            break;
        case ENCOUNTER_SUBSTATE_POST_BATTLE_WON_CHECK_MERLEE:
            if (currentEncounter->hasMerleeCoinBonus) {
                if (get_coin_drop_amount(currentEncounter->curEnemy) != 0) {
                    MerleeDropCoinsEvt = start_script(&EVS_MerleeDropCoins, EVT_PRIORITY_A, 0);
                    MerleeDropCoinsEvt->groupFlags = EVT_GROUP_NEVER_PAUSE;
                    MerleeDropCoinsEvtID = MerleeDropCoinsEvt->id;
                } else {
                    playerData->merleeTurnCount = 0;
                    playerData->merleeCastsLeft++;
                }
            }
            gEncounterSubState = ENCOUNTER_SUBSTATE_POST_BATTLE_PLAY_NPC_DEFEAT;
            break;
        case ENCOUNTER_SUBSTATE_POST_BATTLE_PLAY_NPC_DEFEAT:
            // fade screen in and wait for merlee bonus to finish (if applicable)
            if (currentEncounter->hasMerleeCoinBonus) {
                if (get_coin_drop_amount(currentEncounter->curEnemy) != 0) {
                    currentEncounter->fadeOutAccel += 4;
                    currentEncounter->fadeOutAmount -= currentEncounter->fadeOutAccel;
                    if (currentEncounter->fadeOutAmount < 0) {
                        currentEncounter->fadeOutAmount = 0;
                    }
                    if (does_script_exist(MerleeDropCoinsEvtID)) {
                        break;
                    }
                }
            }
            // start defeat scripts for current enemy
            encounter = currentEncounter->curEncounter;
            for (i = 0; i < encounter->count; i++) {
                enemy = encounter->enemy[i];
                if (enemy == NULL) {
                    continue;
                }
                if ((enemy->flags & ENEMY_FLAG_ENABLE_HIT_SCRIPT) && enemy != currentEncounter->curEnemy) {
                    continue;
                }
                if (enemy->flags & ENEMY_FLAG_DISABLE_AI) {
                    continue;
                }
                if (enemy->defeatBytecode != NULL) {
                    script = start_script_in_group(enemy->defeatBytecode, EVT_PRIORITY_A, 0, EVT_GROUP_NEVER_PAUSE);
                    enemy->defeatScript = script;
                    enemy->defeatScriptID = script->id;
                    script->owner1.enemy = enemy;
                    script->owner2.npcID = enemy->npcID;
                    script->groupFlags = EVT_GROUP_NEVER_PAUSE;
                    currentEncounter->battleStartCountdown = 1;
                } else {
                    script = start_script_in_group(&EVS_NpcDefeat, EVT_PRIORITY_A, 0, EVT_GROUP_NEVER_PAUSE);
                    enemy->defeatScript = script;
                    enemy->defeatScriptID = script->id;
                    script->owner1.enemy = enemy;
                    script->owner2.npcID = enemy->npcID;
                    script->groupFlags = EVT_GROUP_NEVER_PAUSE;
                }
            }
            if (!(currentEncounter->flags & ENCOUNTER_FLAG_THUMBS_UP)
                && !PendingPartnerAbilityResume
                && currentEncounter->battleStartCountdown == 0
                && !LastBattleStartedBySpin
            ) {
                suggest_player_anim_allow_backward(ANIM_Mario1_ThumbsUp);
            }
            gEncounterSubState = ENCOUNTER_SUBSTATE_POST_BATTLE_WON_FADE_IN;
            break;
        case ENCOUNTER_SUBSTATE_POST_BATTLE_WON_FADE_IN:
            if (currentEncounter->fadeOutAmount == 0) {
                gEncounterSubState = ENCOUNTER_SUBSTATE_POST_BATTLE_WON_KILL;
            } else {
                currentEncounter->fadeOutAccel += 4;
                currentEncounter->fadeOutAmount -= currentEncounter->fadeOutAccel;
                if (currentEncounter->fadeOutAmount < 0) {
                    currentEncounter->fadeOutAmount = 0;
                }
            }
            break;
        case ENCOUNTER_SUBSTATE_POST_BATTLE_WON_KILL:
            // wait for all defeat scripts to finish
            hasDefeatScript = FALSE;
            encounter = currentEncounter->curEncounter;
            for (i = 0; i < encounter->count; i++) {
                enemy = encounter->enemy[i];
                if (enemy == NULL) {
                    continue;
                }
                if ((enemy->flags & ENEMY_FLAG_ENABLE_HIT_SCRIPT) && enemy != currentEncounter->curEnemy) {
                    continue;
                }
                if (enemy->flags & ENEMY_FLAG_DISABLE_AI) {
                    continue;
                }
                if (does_script_exist(enemy->defeatScriptID)) {
                    hasDefeatScript = TRUE;
                } else {
                    enemy->defeatScript = NULL;
                }
            }
            // kill defeated enemies
            if (!hasDefeatScript) {
                if (!(currentEncounter->flags & ENCOUNTER_FLAG_THUMBS_UP)
                    && !PendingPartnerAbilityResume
                    && currentEncounter->battleStartCountdown == 1
                ) {
                    suggest_player_anim_allow_backward(ANIM_Mario1_ThumbsUp);
                }
                encounter = currentEncounter->curEncounter;
                for (i = 0; i < encounter->count; i++) {
                    enemy = encounter->enemy[i];
                    enemy = encounter->enemy[i];
                    if (enemy == NULL) {
                        continue;
                    }
                    if (enemy->flags & ENEMY_FLAG_DO_NOT_KILL) {
                        continue;
                    }
                    if ((enemy->flags & ENEMY_FLAG_ENABLE_HIT_SCRIPT) && enemy != currentEncounter->curEnemy) {
                        continue;
                    }
                    if (!(enemy->flags & ENEMY_FLAG_PASSIVE)) {
                        if (!(enemy->flags & ENEMY_FLAG_FLED)) {
                            set_defeated(currentEncounter->mapID, encounter->encounterID + i);
                        }
                    }
                    kill_enemy(enemy);
                }
 
                currentEncounter->substateDelay = 0;
                if (!(currentEncounter->flags & ENCOUNTER_FLAG_THUMBS_UP)
                    && !PendingPartnerAbilityResume
                    && currentEncounter->battleStartCountdown == 1
                ) {
                    currentEncounter->substateDelay = 30;
                }
                gEncounterSubState = ENCOUNTER_SUBSTATE_POST_BATTLE_WON_RESUME;
            }
            break;
        case ENCOUNTER_SUBSTATE_POST_BATTLE_WON_RESUME:
            if (!(currentEncounter->flags & ENCOUNTER_FLAG_CANT_SKIP_WIN_DELAY)) {
                if (gGameStatusPtr->stickX[0] != 0 || gGameStatusPtr->stickY[0] != 0) {
                    currentEncounter->substateDelay = 0;
                }
            }
            if (currentEncounter->substateDelay != 0) {
                currentEncounter->substateDelay--;
                break;
            }
 
            for (i = 0; i < currentEncounter->numEncounters; i++) {
                encounter = currentEncounter->encounterList[i];
                if (encounter == NULL) {
                    continue;
                }
                for (j = 0; j < encounter->count; j++) {
                    enemy = encounter->enemy[j];
                    if (enemy == NULL || (enemy->flags & ENEMY_FLAG_DISABLE_AI)) {
                        continue;
                    }
                    if (enemy->aiScript != NULL) {
                        resume_all_script(enemy->aiScriptID);
                    }
                    if (enemy->auxScript != NULL) {
                        resume_all_script(enemy->auxScriptID);
                    }
                }
            }
 
            currentEncounter->battleTriggerCooldown = 15;
            enable_player_input();
            partner_enable_input();
            if (!PendingPartnerAbilityResume) {
                suggest_player_anim_allow_backward(ANIM_Mario1_Idle);
            }
            set_screen_overlay_params_front(OVERLAY_NONE, -1.0f);
            resume_all_group(EVT_GROUP_FLAG_BATTLE);
            gEncounterState = ENCOUNTER_STATE_NEUTRAL;
            EncounterStateChanged = TRUE;
            gEncounterSubState = ENCOUNTER_SUBSTATE_NEUTRAL;
            break;
        case ENCOUNTER_SUBSTATE_POST_BATTLE_FLED_INIT:
            encounter = currentEncounter->curEncounter;
            for (i = 0; i < encounter->count; i++) {
                enemy = encounter->enemy[i];
                if (enemy == NULL) {
                    continue;
                }
                if ((enemy->flags & ENEMY_FLAG_ENABLE_HIT_SCRIPT) && enemy != currentEncounter->curEnemy) {
                    continue;
                }
                if (enemy->flags & ENEMY_FLAG_DISABLE_AI) {
                    continue;
                }
 
                if (enemy->defeatBytecode != NULL) {
                    script = start_script(enemy->defeatBytecode, EVT_PRIORITY_A, 0);
                    enemy->defeatScript = script;
                    enemy->defeatScriptID = script->id;
                    enemy->aiFlags |= AI_FLAG_1;
                    script->owner1.enemy = enemy;
                    script->owner2.npcID = enemy->npcID;
                    script->groupFlags = enemy->scriptGroup;
                }
            }
            gEncounterSubState = ENCOUNTER_SUBSTATE_POST_BATTLE_FLED_FADE_IN;
            break;
        case ENCOUNTER_SUBSTATE_POST_BATTLE_FLED_FADE_IN:
            if (currentEncounter->fadeOutAmount == 0) {
                gEncounterSubState = ENCOUNTER_SUBSTATE_POST_BATTLE_FLED_RESUME;
            } else {
                currentEncounter->fadeOutAccel += 4;
                currentEncounter->fadeOutAmount -= currentEncounter->fadeOutAccel;
                if (currentEncounter->fadeOutAmount < 0) {
                    currentEncounter->fadeOutAmount = 0;
                }
            }
            break;
        case ENCOUNTER_SUBSTATE_POST_BATTLE_FLED_RESUME:
            encounter = currentEncounter->curEncounter;
            hasDefeatScript = FALSE;
            for (i = 0; i < encounter->count; i++) {
                enemy = encounter->enemy[i];
                if (enemy == NULL) {
                    continue;
                }
                if (!(enemy->flags & ENEMY_FLAG_DISABLE_AI)) {
                    if (does_script_exist(enemy->defeatScriptID)) {
                        hasDefeatScript = TRUE;
                    } else {
                        enemy->defeatScript = NULL;
                    }
                }
            }
            if (!hasDefeatScript) {
                for (i = 0; i < currentEncounter->numEncounters; i++) {
                    encounter = currentEncounter->encounterList[i];
                    if (encounter == NULL) {
                        continue;
                    }
                    for (j = 0; j < encounter->count; j++) {
                        enemy = encounter->enemy[j];
                        if (enemy == NULL || (enemy->flags & ENEMY_FLAG_DISABLE_AI)) {
                            continue;
                        }
                        if (enemy->aiScript != NULL) {
                            resume_all_script(enemy->aiScriptID);
                        }
                        if (enemy->auxScript != NULL) {
                            resume_all_script(enemy->auxScriptID);
                        }
                    }
                }
 
                enemy = currentEncounter->curEnemy;
                encounter = currentEncounter->curEncounter;
                if (!(enemy->flags & ENEMY_FLAG_NO_DELAY_AFTER_FLEE)) {
                    enemy->aiSuspendTime = 45;
                    playerStatus->blinkTimer = 45;
                    for (j = 0; j < encounter->count; j++) {
                        enemy = encounter->enemy[j];
                        if (enemy == NULL) {
                            continue;
                        }
                        if (enemy->flags & ENEMY_FLAG_DISABLE_AI) {
                            continue;
                        }
                        if (enemy->flags & ENEMY_FLAG_ENABLE_HIT_SCRIPT) {
                            continue;
                        }
                        enemy->aiSuspendTime = 45;
                        playerStatus->blinkTimer = 45;
                    }
                }
 
                enemy = currentEncounter->curEnemy;
                if (!(currentEncounter->flags & ENCOUNTER_FLAG_SKIP_FLEE_DROPS)) {
                    script = start_script(&EVS_FleeBattleDrops, EVT_PRIORITY_A, 0);
                    enemy->defeatScript = script;
                    enemy->defeatScriptID = script->id;
                    script->owner1.enemy = enemy;
                    script->owner2.npcID = enemy->npcID;
                    script->groupFlags = enemy->scriptGroup;
                }
 
                currentEncounter->battleTriggerCooldown = 45;
                playerStatus->blinkTimer = 45;
                enable_player_input();
                partner_enable_input();
                set_screen_overlay_params_front(OVERLAY_NONE, -1.0f);
                if (!PendingPartnerAbilityResume) {
                    currentEncounter->substateDelay = 15;
                } else {
                    currentEncounter->substateDelay = 0;
                }
                gEncounterSubState = ENCOUNTER_SUBSTATE_POST_BATTLE_FLED_DELAY;
            }
            break;
        case ENCOUNTER_SUBSTATE_POST_BATTLE_FLED_DELAY:
            if (currentEncounter->substateDelay != 0) {
                currentEncounter->substateDelay--;
                if (gGameStatusPtr->curButtons[0] == 0 && gGameStatusPtr->stickX[0] == 0 && gGameStatusPtr->stickY[0] == 0) {
                    break;
                }
            }
            if (!PendingPartnerAbilityResume && playerStatus->anim == ANIM_MarioB3_Hustled) {
                suggest_player_anim_allow_backward(ANIM_Mario1_Idle);
            }
            resume_all_group(EVT_GROUP_FLAG_BATTLE);
            gEncounterState = ENCOUNTER_STATE_NEUTRAL;
            EncounterStateChanged = TRUE;
            gEncounterSubState = ENCOUNTER_SUBSTATE_NEUTRAL;
            break;
        case ENCOUNTER_SUBSTATE_POST_BATTLE_LOST_INIT:
            suggest_player_anim_allow_backward(ANIM_MarioW2_LayingDown);
            encounter = currentEncounter->curEncounter;
            for (i = 0; i < encounter->count; i++) {
                enemy = encounter->enemy[i];
                if (enemy == NULL) {
                    continue;
                }
                if ((enemy->flags & ENEMY_FLAG_ENABLE_HIT_SCRIPT) && enemy != currentEncounter->curEnemy) {
                    continue;
                }
 
                if (enemy->flags & ENEMY_FLAG_DISABLE_AI) {
                    continue;
                }
 
                if (enemy->defeatBytecode != NULL) {
                    script = start_script(enemy->defeatBytecode, EVT_PRIORITY_A, 0);
                    enemy->defeatScript = script;
                    enemy->defeatScriptID = script->id;
                    script->owner1.enemy = enemy;
                    script->owner2.npcID = enemy->npcID;
                    script->groupFlags = enemy->scriptGroup;
                }
            }
            gEncounterSubState = ENCOUNTER_SUBSTATE_POST_BATTLE_LOST_FADE_IN;
            break;
        case ENCOUNTER_SUBSTATE_POST_BATTLE_LOST_FADE_IN:
            if (currentEncounter->fadeOutAmount == 0) {
                gEncounterSubState = ENCOUNTER_SUBSTATE_POST_BATTLE_LOST_RESUME;
            } else {
                currentEncounter->fadeOutAccel += 4;
                currentEncounter->fadeOutAmount -= currentEncounter->fadeOutAccel;
                if (currentEncounter->fadeOutAmount < 0) {
                    currentEncounter->fadeOutAmount = 0;
                }
            }
            break;
        case ENCOUNTER_SUBSTATE_POST_BATTLE_LOST_RESUME:
            hasDefeatScript = FALSE;
            encounter = currentEncounter->curEncounter;
            for (i = 0; i < encounter->count; i++) {
                enemy = encounter->enemy[i];
                if (enemy == NULL) {
                    continue;
                }
                if (!(enemy->flags & ENEMY_FLAG_DISABLE_AI)) {
                    if (does_script_exist(enemy->defeatScriptID)) {
                        hasDefeatScript = TRUE;
                    } else {
                        enemy->defeatScript = NULL;
                    }
                }
            }
            if (!hasDefeatScript) {
                for (i = 0; i < currentEncounter->numEncounters; i++) {
                    encounter = currentEncounter->encounterList[i];
                    if (encounter == NULL) {
                        continue;
                    }
                    for (j = 0; j < encounter->count; j++) {
                        enemy = encounter->enemy[j];
                        if (enemy == NULL || (enemy->flags & ENEMY_FLAG_DISABLE_AI)) {
                            continue;
                        }
                        if (enemy->aiScript != NULL) {
                            resume_all_script(enemy->aiScriptID);
                        }
                        if (enemy->auxScript != NULL) {
                            resume_all_script(enemy->auxScriptID);
                        }
                    }
                }
                enable_player_input();
                partner_enable_input();
                set_screen_overlay_params_front(OVERLAY_NONE, -1.0f);
                currentEncounter->substateDelay = 15;
                gEncounterSubState = ENCOUNTER_SUBSTATE_POST_BATTLE_LOST_DELAY;
            }
            break;
        case ENCOUNTER_SUBSTATE_POST_BATTLE_LOST_DELAY:
            if (currentEncounter->substateDelay != 0) {
                currentEncounter->substateDelay--;
                if (gGameStatusPtr->curButtons[0] == 0 && gGameStatusPtr->stickX[0] == 0 && gGameStatusPtr->stickY[0] == 0) {
                    break;
                }
            }
            resume_all_group(EVT_GROUP_FLAG_BATTLE);
            gEncounterState = ENCOUNTER_STATE_NEUTRAL;
            EncounterStateChanged = TRUE;
            gEncounterSubState = ENCOUNTER_SUBSTATE_NEUTRAL;
            break;
        case ENCOUNTER_SUBSTATE_POST_BATTLE_SKIP:
            // resume all ai scripts
            for (i = 0; i < currentEncounter->numEncounters; i++) {
                encounter = currentEncounter->encounterList[i];
                if (encounter == NULL) {
                    continue;
                }
                for (j = 0; j < encounter->count; j++) {
                    enemy = encounter->enemy[j];
                    if (enemy == NULL || (enemy->flags & ENEMY_FLAG_DISABLE_AI)) {
                        continue;
                    }
                    if (enemy->aiScript != NULL) {
                        resume_all_script(enemy->aiScriptID);
                    }
                    if (enemy->auxScript != NULL) {
                        resume_all_script(enemy->auxScriptID);
                    }
                }
            }
            enable_player_input();
            partner_enable_input();
            set_screen_overlay_params_front(OVERLAY_NONE, -1.0f);
            resume_all_group(EVT_GROUP_FLAG_BATTLE);
            gEncounterState = ENCOUNTER_STATE_NEUTRAL;
            EncounterStateChanged = TRUE;
            gEncounterSubState = ENCOUNTER_SUBSTATE_NEUTRAL;
            break;
        case ENCOUNTER_SUBSTATE_POST_BATTLE_ENEMY_FLED_INIT:
            encounter = currentEncounter->curEncounter;
            for (i = 0; i < encounter->count; i++) {
                enemy = encounter->enemy[i];
                if (enemy == NULL) {
                    continue;
                }
                if ((enemy->flags & ENEMY_FLAG_ENABLE_HIT_SCRIPT) && enemy != currentEncounter->curEnemy) {
                    continue;
                }
 
                if (enemy->flags & ENEMY_FLAG_DISABLE_AI) {
                    continue;
                }
 
                if (enemy->defeatBytecode != NULL) {
                    script = start_script(enemy->defeatBytecode, EVT_PRIORITY_A, 0);
                    enemy->defeatScript = script;
                    enemy->defeatScriptID = script->id;
                    script->owner1.enemy = enemy;
                    script->owner2.npcID = enemy->npcID;
                    script->groupFlags = enemy->scriptGroup;
                }
            }
            gEncounterSubState = ENCOUNTER_SUBSTATE_POST_BATTLE_ENEMY_FLED_FADE_IN;
            break;
        case ENCOUNTER_SUBSTATE_POST_BATTLE_ENEMY_FLED_FADE_IN:
            if (currentEncounter->fadeOutAmount == 0) {
                gEncounterSubState = ENCOUNTER_SUBSTATE_POST_BATTLE_ENEMY_FLED_RESUME;
            } else {
                currentEncounter->fadeOutAccel += 4;
                currentEncounter->fadeOutAmount -= currentEncounter->fadeOutAccel;
                if (currentEncounter->fadeOutAmount < 0) {
                    currentEncounter->fadeOutAmount = 0;
                }
            }
            break;
        case ENCOUNTER_SUBSTATE_POST_BATTLE_ENEMY_FLED_RESUME:
            hasDefeatScript = FALSE;
            encounter = currentEncounter->curEncounter;
            for (i = 0; i < encounter->count; i++) {
                enemy = encounter->enemy[i];
                if (enemy == NULL) {
                    continue;
                }
                if (!(enemy->flags & ENEMY_FLAG_DISABLE_AI)) {
                    if (does_script_exist(enemy->defeatScriptID)) {
                        hasDefeatScript = TRUE;
                    } else {
                        enemy->defeatScript = NULL;
                    }
                }
            }
            if (!hasDefeatScript) {
                for (i = 0; i < currentEncounter->numEncounters; i++) {
                    encounter = currentEncounter->encounterList[i];
                    if (encounter == NULL) {
                        continue;
                    }
                    for (j = 0; j < encounter->count; j++) {
                        enemy = encounter->enemy[j];
                        if (enemy == NULL || (enemy->flags & ENEMY_FLAG_DISABLE_AI)) {
                            continue;
                        }
                        if (enemy->aiScript != NULL) {
                            resume_all_script(enemy->aiScriptID);
                        }
                        if (enemy->auxScript != NULL) {
                            resume_all_script(enemy->auxScriptID);
                        }
                    }
                }
 
                enemy = currentEncounter->curEnemy;
                if (!(enemy->flags & ENEMY_FLAG_DO_NOT_KILL)) {
                    encounter = currentEncounter->curEncounter;
                    enemy->aiSuspendTime = 45;
                    playerStatus->blinkTimer = 45;
                    for (j = 0; j < encounter->count; j++) {
                        enemy = encounter->enemy[j];
                        if (enemy == NULL) {
                            continue;
                        }
                        if (enemy->flags & ENEMY_FLAG_DISABLE_AI) {
                            continue;
                        }
                        if (enemy->flags & ENEMY_FLAG_ENABLE_HIT_SCRIPT) {
                            continue;
                        }
                        enemy->aiSuspendTime = 45;
                        playerStatus->blinkTimer = 45;
                    }
                }
 
                currentEncounter->battleTriggerCooldown = 45;
                enable_player_input();
                partner_enable_input();
                set_screen_overlay_params_front(OVERLAY_NONE, -1.0f);
                resume_all_group(EVT_GROUP_FLAG_BATTLE);
                gEncounterState = ENCOUNTER_STATE_NEUTRAL;
                EncounterStateChanged = TRUE;
                gEncounterSubState = ENCOUNTER_SUBSTATE_NEUTRAL;
            }
            break;
    }
 
    for (i = 0; i < currentEncounter->numEncounters; i++) {
        encounter = currentEncounter->encounterList[i];
        if (encounter == NULL) {
            continue;
        }
        for (j = 0; j < encounter->count; j++) {
            enemy = encounter->enemy[j];
            if (enemy == NULL || (enemy->flags & ENEMY_FLAG_DISABLE_AI)) {
                continue;
            }
 
            npc = get_npc_unsafe(enemy->npcID);
            if (enemy->aiSuspendTime != 0) {
                if (enemy->aiSuspendTime & 1) {
                    npc->flags |= NPC_FLAG_SUSPENDED;
                    enemy->flags |= ENEMY_FLAG_SUSPENDED;
                } else {
                    npc->flags &= ~NPC_FLAG_SUSPENDED;
                    enemy->flags &= ~ENEMY_FLAG_SUSPENDED;
                }
            }
        }
    }
}

Referenced by update_encounters().

◆ load_map_bg()

void load_map_bg ( char * optAssetName )

Definition at line 14 of file background.c.

                                     {
    if (optAssetName != NULL) {
        UNK_PTR compressedData;
        u32 assetSize;
        char* assetName = optAssetName;
 
        if (evt_get_variable(NULL, GB_StoryProgress) >= STORY_CH6_DESTROYED_PUFF_PUFF_MACHINE) {
            // Use sunny Flower Fields bg rather than cloudy
            if (strcmp(assetName, gCloudyFlowerFieldsBg) == 0) {
                assetName = gSunnyFlowerFieldsBg;
            }
        }
 
        compressedData = load_asset_by_name(assetName, &assetSize);
        decode_yay0(compressedData, &gBackgroundImage);
        general_heap_free(compressedData);
    }
}

Referenced by btl_state_update_normal_start(), load_map_by_IDs(), state_init_title_screen(), state_step_end_battle(), and state_step_unpause().

◆ reset_background_settings()

void reset_background_settings ( void )

Definition at line 33 of file background.c.

                                     {
    gBackroundLastScrollValue = 0;
    gBackroundWaveEnabled = FALSE;
    gGameStatusPtr->backgroundDarkness = 180;
    gGameStatusPtr->backgroundFlags &= BACKGROUND_RENDER_STATE_MASK;
}

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(), and state_step_startup().

◆ func_80138188()

void func_80138188 ( void )

Definition at line 469 of file screen_overlays.c.

                         {
    screen_overlay_backZoom = 0;
}

Referenced by load_demo_battle(), and load_map_by_IDs().

◆ func_80266970()

void func_80266970 ( Actor * target )

Definition at line 2439 of file 190B20.c.

                                  {
    target->actionRatingCombo = 0;
}

Referenced by calc_enemy_damage_target(), calc_item_damage_enemy(), calc_partner_damage_enemy(), and calc_player_damage_enemy().

◆ show_actor_health_bar()

void show_actor_health_bar ( Actor * target )

Definition at line 2505 of file 190B20.c.

                                          {
    target->healthBarHideTime = -1;
    target->flags |= ACTOR_FLAG_HEALTH_BAR_HIDDEN;
}

Referenced by calc_enemy_damage_target(), calc_item_damage_enemy(), calc_partner_damage_enemy(), and calc_player_damage_enemy().

◆ hide_actor_health_bar()

void hide_actor_health_bar ( Actor * target )

Definition at line 2510 of file 190B20.c.

                                          {
    target->healthBarHideTime = 0;
    target->flags &= ~ACTOR_FLAG_HEALTH_BAR_HIDDEN;
}

◆ clear_part_pal_adjustment()

void clear_part_pal_adjustment ( ActorPart * part )

Definition at line 2618 of file 190B20.c.

                                                {
    if (part->idleAnimations != NULL && !(part->flags & ACTOR_PART_FLAG_NO_DECORATIONS)) {
        part->decorationTable->paletteAdjustment = ACTOR_PAL_ADJUST_NONE;
    }
}

Referenced by calc_enemy_damage_target(), calc_partner_damage_enemy(), and calc_player_damage_enemy().

◆ calculate_camera_yinterp_rate()

void calculate_camera_yinterp_rate ( void )

Definition at line 183 of file 7B440.c.

                                         {
    Shadow* shadow = get_shadow_by_index(gPlayerStatus.shadowID);
    f32 x = shadow->rot.x + 180.0;
    f32 z = shadow->rot.z + 180.0;
    Camera* camera = &gCameras[CAM_DEFAULT];
    f32 rate;
 
    if (x != 0.0f || z != 0.0f) {
        switch (gPlayerStatus.actionState) {
            case ACTION_STATE_JUMP:
            case ACTION_STATE_FALLING:
                rate = 32.0f;
                camera->yinterpRate = rate;
                break;
            case ACTION_STATE_WALK:
            case ACTION_STATE_RUN:
                if (camera->targetScreenCoords.y < 130) {
                    camera->yinterpRate = 3.0f;
                    break;
                }
                rate = 3.0f;
                if (PlayerYInterpUpdateDelay++ <= 10) {
                    return;
                }
                PlayerYInterpUpdateDelay = 10;
                camera->yinterpRate -= 2.0f;
                if (camera->yinterpRate < rate) {
                    camera->yinterpRate = rate;
                }
                break;
            case ACTION_STATE_SLIDING:
                rate = 3.0f;
                camera->yinterpRate = rate;
                break;
            default:
                rate = 3.0f;
                PlayerYInterpUpdateDelay = 0;
                camera->yinterpRate -= 2.0f;
                if (camera->yinterpRate < rate) {
                    camera->yinterpRate = rate;
                }
                break;
        }
    } else {
        switch (gPlayerStatus.actionState) {
            case ACTION_STATE_WALK:
            case ACTION_STATE_RUN:
            case ACTION_STATE_JUMP:
            case ACTION_STATE_SLIDING:
                rate = 7.2f;
                break;
            default:
                rate = 24.0f;
                break;
        }
 
        camera->yinterpRate = rate;
    }
}

Referenced by phys_peach_update(), and phys_update_action_state().

◆ load_tattle_flags()

void load_tattle_flags ( s32 actorType )

Definition at line 571 of file 181810.c.

                                      {
    BattleStatus* battleStatus = &gBattleStatus;
    u8* types;
    s32 gb;
    s32 i = 0;
    s32 j;
    s32 k;
 
    while (TRUE) {
        types = ActorTypesLists[i];
        if (types == NULL) {
            break;
        }
 
        for (j = 0; types[j] != ACTOR_TYPE_LIST_END; j++) {
            if (actorType == types[j]) {
                for (k = 0; types[k] != ACTOR_TYPE_LIST_END; k++) {
                    actorType = types[k];
 
                    gb = get_global_byte(EVT_INDEX_OF_GAME_BYTE(GB_Tattles_00) + actorType / 8);
                    gb |= 1 << (actorType % 8);
                    battleStatus->tattleFlags[actorType / 8] |= gb;
                }
                return;
            }
        }
        i++;
    }
 
    gb = get_global_byte(EVT_INDEX_OF_GAME_BYTE(GB_Tattles_00) + actorType / 8);
    gb |= 1 << (actorType % 8);
    battleStatus->tattleFlags[actorType / 8] |= gb;
}

◆ use_consumable()

s32 use_consumable ( s32 invSlot )

Definition at line 479 of file partners.c.

                                {
    Evt* script;
 
    D_8010CD20 = invSlot;
    invSlot = gPlayerData.invItems[invSlot];
    dma_copy(UseItemDmaArgs.dmaStart, UseItemDmaArgs.dmaEnd, world_use_item_VRAM);
    script = start_script(UseItemDmaArgs.main, EVT_PRIORITY_1, 0);
    script->varTable[10] = invSlot;
    return script->id;
}

Referenced by check_input_open_menus().

◆ remove_consumable()

void remove_consumable ( void )

Definition at line 490 of file partners.c.

                             {
    gPlayerData.invItems[D_8010CD20] = ITEM_NONE;
    sort_consumables();
}

◆ delete_shadow()

void delete_shadow ( s32 shadowIndex )

Definition at line 626 of file entity.c.

                                    {
    Shadow* shadow = get_shadow_by_index(shadowIndex);
 
    free_entity_model_by_index(shadow->entityModelID);
    heap_free((*gCurrentShadowListPtr)[shadowIndex]);
    (*gCurrentShadowListPtr)[shadowIndex] = NULL;
}

Referenced by btl_delete_actor(), btl_delete_player_actor(), free_npc(), free_npc_by_index(), remove_item_entity_by_index(), remove_item_entity_by_reference(), remove_part_shadow(), and update_shadows().

◆ partner_reset_tether_distance()

void partner_reset_tether_distance ( void )

Definition at line 2405 of file partners.c.

                                         {
    wPartnerTetherDistance = 40.0f;
}

Referenced by check_for_interactables(), and interact_inspect_dismiss().

◆ save_tattle_flags()

void save_tattle_flags ( s32 actorType )

Definition at line 535 of file 181810.c.

                                      {
    BattleStatus* battleStatus = &gBattleStatus;
    u8* types;
    s32 gb;
    s32 i = 0;
    s32 j;
    s32 k;
 
    while (TRUE) {
        types = ActorTypesLists[i];
        if (types == NULL) {
            break;
        }
 
        for (j = 0; types[j] != ACTOR_TYPE_LIST_END; j++) {
            if (actorType == types[j]) {
                for (k = 0; types[k] != ACTOR_TYPE_LIST_END; k++) {
                    actorType = types[k];
 
                    gb = get_global_byte(EVT_INDEX_OF_GAME_BYTE(GB_Tattles_00) + actorType / 8);
                    gb |= 1 << (actorType % 8);
                    set_global_byte(EVT_INDEX_OF_GAME_BYTE(GB_Tattles_00) + actorType / 8, gb);
                    battleStatus->tattleFlags[actorType / 8] |= gb;
                }
                return;
            }
        }
        i++;
    }
 
    gb = get_global_byte(EVT_INDEX_OF_GAME_BYTE(GB_Tattles_00) + actorType / 8);
    gb |= 1 << (actorType % 8);
    set_global_byte(EVT_INDEX_OF_GAME_BYTE(GB_Tattles_00) + actorType / 8, gb);
    battleStatus->tattleFlags[actorType / 8] |= gb;
}

◆ update_merlee_messages()

void update_merlee_messages ( void )

Definition at line 150 of file status_icons.c.

                                  {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(D_800A0BC0); i++) {
        PopupMessage* popup = &D_800A0BC0[i];
        if (popup->active && popup->updateFunc != NULL) {
            popup->updateFunc(popup);
        }
    }
}

Referenced by update_encounters().

◆ draw_merlee_messages()

void draw_merlee_messages ( void )

Definition at line 172 of file status_icons.c.

                                {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(D_800A0BC0); i++) {
        PopupMessage* popup = &D_800A0BC0[i];
        if (popup->active && popup->renderUIFunc != NULL) {
            popup->renderUIFunc(popup);
        }
    }
}

Referenced by draw_encounter_ui().

◆ show_merlee_message()

void show_merlee_message	(	s16	messageIndex,
		s16	duration )

Definition at line 205 of file status_icons.c.

                                                         {
    PopupMessage* popup = get_current_merlee_message();
 
    if (popup != NULL) {
        popup->updateFunc = update_merlee_message;
        popup->renderUIFunc = draw_merlee_message;
        popup->needsInit = TRUE;
        popup->unk_00 = 0;
        popup->renderWorldFunc = NULL;
        popup->messageIndex = messageIndex;
        popup->duration = duration;
        popup->showMsgState = BTL_MSG_STATE_INIT;
        D_800A0F40 = 1;
    }
}

◆ is_merlee_message_done()

s32 is_merlee_message_done ( void )

Definition at line 331 of file status_icons.c.

                                 {
    return D_800A0F40;
}

◆ close_action_command_instruction_popup()

void close_action_command_instruction_popup ( void )

Definition at line 645 of file popup_messages.c.

                                                  {
    PopupMessage* popup = bPopupMessage;
 
    if (popup != NULL
        && popup->messageIndex <= BTL_MSG_LAST_ACTION_TIP
        && popup->messageIndex >= BTL_MSG_FIRST_ACTION_TIP
    ) {
        popup->duration = 0;
    }
}

Referenced by action_command_free(), and btl_state_update_player_move().

◆ draw_encounters_conversation()

void draw_encounters_conversation ( void )

Definition at line 2319 of file encounter.c.

2319 {

2320}

Referenced by draw_encounter_ui().

◆ draw_encounters_post_battle()

void draw_encounters_post_battle ( void )

Definition at line 2253 of file encounter.c.

                                       {
    EncounterStatus* currentEncounter = &gCurrentEncounter;
    s32 ret = currentEncounter->fadeOutAccel;
 
    if (ret != 0) {
        set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, currentEncounter->fadeOutAmount);
        set_screen_overlay_color(SCREEN_LAYER_FRONT, 0, 0, 0);
    }
}

Referenced by draw_encounter_ui().

◆ draw_encounters_pre_battle()

void draw_encounters_pre_battle ( void )

Definition at line 1487 of file encounter.c.

                                      {
    EncounterStatus* encounter = &gCurrentEncounter;
    PlayerStatus* playerStatus = &gPlayerStatus;
 
#if DX_DEBUG_MENU
    Npc* npc = NULL;
    if (encounter->curEnemy->npcID != (s16) DX_DEBUG_DUMMY_ID) {
        npc = get_npc_unsafe(encounter->curEnemy->npcID);
    }
#else
    Npc* npc = get_npc_unsafe(encounter->curEnemy->npcID);
#endif
 
    if (encounter->substateDelay != 0) {
        f32 playerX, playerY, playerZ;
        f32 otherX, otherY, otherZ;
        s32 pScreenX, pScreenY, pScreenZ;
        s32 oScreenX, oScreenY, oScreenZ;
 
        if (encounter->fadeOutAmount != 255) {
            encounter->fadeOutAccel++;
            if (encounter->fadeOutAccel > 10) {
                encounter->fadeOutAccel = 10;
            }
 
            encounter->fadeOutAmount += encounter->fadeOutAccel;
            if (encounter->fadeOutAmount > 255) {
                encounter->fadeOutAmount = 255;
            }
 
            playerX = playerStatus->pos.x;
            playerY = playerStatus->pos.y;
            playerZ = playerStatus->pos.z;
 
        #if DX_DEBUG_MENU
        if (npc != NULL) {
            otherX = npc->pos.x;
            otherY = npc->pos.y;
            otherZ = npc->pos.z;
        } else {
            otherX = playerX;
            otherY = playerY;
            otherZ = playerZ;
        }
        #else
            otherX = npc->pos.x;
            otherY = npc->pos.y;
            otherZ = npc->pos.z;
        #endif
            if (otherY < -990.0f) {
                otherX = playerX;
                otherY = playerY;
                otherZ = playerZ;
            }
 
            if (gGameStatusPtr->demoState == DEMO_STATE_CHANGE_MAP) {
                set_screen_overlay_params_back(OVERLAY_START_BATTLE, encounter->fadeOutAmount);
                set_screen_overlay_alpha(SCREEN_LAYER_BACK, 255.0f);
                set_screen_overlay_color(SCREEN_LAYER_BACK, 0, 0, 0);
                get_screen_coords(gCurrentCameraID, playerX, playerY + 20.0f, playerZ, &pScreenX, &pScreenY, &pScreenZ);
                get_screen_coords(gCurrentCameraID, otherX, otherY + 15.0f, otherZ, &oScreenX, &oScreenY, &oScreenZ);
                set_screen_overlay_center(SCREEN_LAYER_BACK, 0, (pScreenX - oScreenX) / 2 + oScreenX,
                                              (pScreenY - oScreenY) / 2 + oScreenY);
            } else {
                set_screen_overlay_params_front(OVERLAY_START_BATTLE, encounter->fadeOutAmount);
                set_screen_overlay_alpha(SCREEN_LAYER_FRONT, 255.0f);
                set_screen_overlay_color(SCREEN_LAYER_FRONT, 0, 0, 0);
                get_screen_coords(gCurrentCameraID, playerX, playerY + 20.0f, playerZ, &pScreenX, &pScreenY, &pScreenZ);
                get_screen_coords(gCurrentCameraID, otherX, otherY + 15.0f, otherZ, &oScreenX, &oScreenY, &oScreenZ);
                set_screen_overlay_center(SCREEN_LAYER_FRONT, 0, (pScreenX - oScreenX) / 2 + oScreenX,
                                              (pScreenY - oScreenY) / 2 + oScreenY);
            }
        }
    }
}

Referenced by draw_encounter_ui().

◆ draw_encounters_neutral()

void draw_encounters_neutral ( void )

Definition at line 1258 of file encounter.c.

1258 {

1259}

Referenced by draw_encounter_ui().

◆ show_first_strike_message()

void show_first_strike_message ( void )

Definition at line 1563 of file encounter.c.

                                     {
    EncounterStatus* currentEncounter = &gCurrentEncounter;
    s32 posX;
    s32 width;
    s32 xOffset;
    s32 screenWidthHalf;
 
    if (currentEncounter->substateDelay == 0) {
        gFirstStrikeMessagePos = -200;
        return;
    }
 
    gFirstStrikeMessagePos += 40;
    xOffset = gFirstStrikeMessagePos;
    if (xOffset > 0) {
        if (xOffset < 1600) {
            xOffset = 0;
        } else {
            xOffset -= 1600;
        }
    }
 
    screenWidthHalf = SCREEN_WIDTH / 2;
 
    switch (currentEncounter->firstStrikeType) {
        case FIRST_STRIKE_PLAYER:
            switch (currentEncounter->hitType) {
                case ENCOUNTER_TRIGGER_JUMP:
                case ENCOUNTER_TRIGGER_HAMMER:
                    width = get_msg_width(MSG_Menus_PlayerFirstStrike, 0) + 24;
                    posX = (xOffset + screenWidthHalf) - (width / 2);
                    draw_box(0, WINDOW_STYLE_20, posX, 69, 0, width, 28, 255, 0, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, NULL, 0, NULL,
                             SCREEN_WIDTH, SCREEN_HEIGHT, NULL);
                    draw_msg(MSG_Menus_PlayerFirstStrike, posX + 11, 75, 0xFF, MSG_PAL_STANDARD, 0);
                    break;
                case ENCOUNTER_TRIGGER_PARTNER:
                    width = get_msg_width(MSG_Menus_PartnerFirstStrike, 0) + 24;
                    posX = (xOffset + screenWidthHalf) - (width / 2);
                    draw_box(0, WINDOW_STYLE_20, posX, 69, 0, width, 28, 255, 0, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, NULL, 0, NULL,
                             SCREEN_WIDTH, SCREEN_HEIGHT, NULL);
                    draw_msg(MSG_Menus_PartnerFirstStrike, posX + 11, 75, 0xFF, MSG_PAL_STANDARD, 0);
                    break;
            }
            break;
        case FIRST_STRIKE_ENEMY:
            if (!is_ability_active(ABILITY_CHILL_OUT)) {
                width = get_msg_width(MSG_Menus_EnemyFirstStrike, 0) + 24;
                posX = (xOffset + screenWidthHalf) - (width / 2);
                draw_box(0, WINDOW_STYLE_4, posX, 69, 0, width, 28, 255, 0, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, NULL, 0, NULL,
                         SCREEN_WIDTH, SCREEN_HEIGHT, NULL);
                draw_msg(MSG_Menus_EnemyFirstStrike, posX + 11, 75, 0xFF, MSG_PAL_STANDARD, 0);
            }
            break;
    }
}

Referenced by draw_first_strike_ui().

◆ entity_upgrade_block_hide_content()

void entity_upgrade_block_hide_content ( s32 entityIndex )

Definition at line 40 of file SuperBlock.c.

                                                        {
    Entity* entity = get_entity_by_index(entityIndex);
    BlockData* data = entity->dataBuf.block;
 
    if (data->childEntityIndex >= 0) {
        Entity* childEntity = get_entity_by_index(data->childEntityIndex);
        SuperBlockContentData* childEntityData = childEntity->dataBuf.superBlockContent;
        childEntityData->isHidden = TRUE;
    }
}

◆ lookup_defense()

s32 lookup_defense	(	s32 *	defenseTable,
		s32	elementKey )

Definition at line 2027 of file 190B20.c.

                                                      {
    s32 normalDefense = 0;
 
    while (defenseTable[DICTIONARY_KEY] != ELEMENT_END) {
        if (defenseTable[DICTIONARY_KEY] == ELEMENT_NORMAL) {
            normalDefense = defenseTable[DICTIONARY_VALUE];
        }
 
        if (defenseTable[DICTIONARY_KEY] == elementKey) {
            normalDefense = defenseTable[DICTIONARY_VALUE];
            break;
        }
        defenseTable += DICTIONARY_SIZE;
    }
 
    // Fall back to normal defense if given element is not specified in table
    return normalDefense;
}

Referenced by get_defense().

◆ lookup_status_chance()

s32 lookup_status_chance	(	s32 *	statusTable,
		s32	statusKey )

Definition at line 2046 of file 190B20.c.

                                                          {
    s32 defaultChance = 0;
 
    while (statusTable[DICTIONARY_KEY] != STATUS_END) {
        if (statusTable[DICTIONARY_KEY] == STATUS_KEY_DEFAULT) {
            defaultChance = statusTable[DICTIONARY_VALUE];
        }
 
        if (statusTable[DICTIONARY_KEY] == statusKey) {
            defaultChance = statusTable[DICTIONARY_VALUE];
            break;
        }
        statusTable += DICTIONARY_SIZE;
    }
 
    // Fall back to normal chance if given element is not specified in table
    return defaultChance;
}

Referenced by inflict_status_set_duration(), and try_inflict_status().

◆ peach_check_for_parasol_input()

void peach_check_for_parasol_input ( void )

Definition at line 530 of file 7E9D0.c.

                                         {
    PlayerStatus* playerStatus = &gPlayerStatus;
    s32 actionState = playerStatus->actionState;
    Npc* disguiseNpc;
 
    if (actionState == ACTION_STATE_IDLE || actionState == ACTION_STATE_WALK || actionState == ACTION_STATE_RUN) {
        if (PeachDisguiseReapplyDelay != 0) {
            PeachDisguiseReapplyDelay--;
            if (PeachDisguiseReapplyDelay == 0) {
                if (gGameStatusPtr->peachFlags & PEACH_FLAG_DISGUISED) {
                    playerStatus->animFlags |= PA_FLAG_INVISIBLE;
                    gGameStatusPtr->peachFlags |= PEACH_FLAG_DISGUISED;
 
                    disguiseNpc = peach_make_disguise_npc(gGameStatusPtr->peachDisguise);
                    if (disguiseNpc != NULL) {
                        disguiseNpc->flags &= ~NPC_FLAG_IGNORE_CAMERA_FOR_YAW;
                    }
                }
            }
        } else if (gGameStatusPtr->peachFlags & PEACH_FLAG_HAS_PARASOL && playerStatus->pressedButtons & BUTTON_B) {
            set_action_state(ACTION_STATE_USE_SNEAKY_PARASOL);
        }
    }
}

Referenced by phys_peach_update().

◆ peach_sync_disguise_npc()

void peach_sync_disguise_npc ( void )

Definition at line 555 of file 7E9D0.c.

                                   {
    PlayerStatus* playerStatus = &gPlayerStatus;
 
    if (PeachDisguiseNpcIndex >= 0) {
        Npc* npc = get_npc_by_index(PeachDisguiseNpcIndex);
 
        if (npc->flags & NPC_FLAG_IGNORE_CAMERA_FOR_YAW) {
            npc->renderYaw = playerStatus->spriteFacingAngle;
        } else {
            npc->yaw = playerStatus->targetYaw;
        }
 
        npc->pos.x = playerStatus->pos.x;
        npc->pos.y = playerStatus->pos.y;
        npc->pos.z = playerStatus->pos.z;
    }
}

Referenced by action_update_parasol(), and phys_peach_update().

◆ check_conversation_trigger()

b32 check_conversation_trigger ( void )

Definition at line 2322 of file encounter.c.

                                     {
    PlayerStatus* playerStatus = &gPlayerStatus;
    Camera* camera = &gCameras[gCurrentCameraID];
    EncounterStatus* encounterStatus = &gCurrentEncounter;
    f32 npcX, npcY, npcZ;
    f32 angle;
    f32 deltaX, deltaZ;
    Encounter* resultEncounter;
    f32 playerX, playerY, playerZ;
    f32 playerHeight;
    f32 playerRadius;
    f32 length;
    f32 npcHeight;
    f32 npcRadius;
    Encounter* encounter;
    Npc* resultNpc;
    Npc* npc;
    Enemy* resultEnemy;
    Enemy* enemy;
    f32 minLength;
    s32 i, j;
    f32 yaw;
 
    playerStatus->encounteredNPC = NULL;
    playerStatus->flags &= ~PS_FLAG_HAS_CONVERSATION_NPC;
    playerHeight = playerStatus->colliderHeight;
    playerRadius = playerStatus->colliderDiameter / 2;
    playerX = playerStatus->pos.x;
    playerY = playerStatus->pos.y;
    playerZ = playerStatus->pos.z;
 
    if (gPartnerStatus.partnerActionState != PARTNER_ACTION_NONE) {
        return FALSE;
    }
 
    resultEncounter = NULL;
    resultNpc = NULL;
    resultEnemy = NULL;
    minLength = 65535.0f;
 
    for (i = 0; i < encounterStatus->numEncounters; i++) {
        encounter = encounterStatus->encounterList[i];
 
        if (encounter == NULL) {
            continue;
        }
 
        for (j = 0; j < encounter->count; j++) {
            enemy = encounter->enemy[j];
 
            if (enemy == NULL) {
                continue;
            }
 
            if (enemy->flags & (ENEMY_FLAG_SUSPENDED | ENEMY_FLAG_DISABLE_AI)) {
                continue;
            }
 
            if (!(enemy->flags & ENEMY_FLAG_PASSIVE)) {
                continue;
            }
 
            if ((enemy->flags & ENEMY_FLAG_CANT_INTERACT) || enemy->interactBytecode == NULL) {
                continue;
            }
 
            npc = get_npc_unsafe(enemy->npcID);
 
            npcX = npc->pos.x;
            npcY = npc->pos.y;
            npcZ = npc->pos.z;
            deltaX = npcX - playerX;
            deltaZ = npcZ - playerZ;
            npcHeight = npc->collisionHeight;
            npcRadius = npc->collisionDiameter;
            length = sqrtf(SQ(deltaX) + SQ(deltaZ));
 
            // check cylinder-cylinder overlap
            if ((playerRadius + npcRadius <= length) ||
                (npcY + npcHeight < playerY) ||
                (playerY + playerHeight < npcY)) {
                continue;
            }
 
            if (clamp_angle(playerStatus->spriteFacingAngle) < 180.0f) {
                angle = clamp_angle(camera->curYaw - 120.0f);
                if (playerStatus->trueAnimation & SPRITE_ID_BACK_FACING) {
                    angle = clamp_angle(angle + 60.0f);
                }
            } else {
                angle = clamp_angle(camera->curYaw + 120.0f);
                if (playerStatus->trueAnimation & SPRITE_ID_BACK_FACING) {
                    angle = clamp_angle(angle - 60.0f);
                }
            }
 
            yaw = atan2(playerX, playerZ, npcX, npcZ);
            if (fabsf(get_clamped_angle_diff(angle, yaw)) > 90.0f) {
                continue;
            }
 
            // only allow interact if line of sight exists
            // @bug? flag combination does not make sense
            if (!(enemy->flags & ENEMY_FLAG_RAYCAST_TO_INTERACT) && npc->flags & NPC_FLAG_RAYCAST_TO_INTERACT) {
                f32 x = npcX;
                f32 y = npcY;
                f32 z = npcZ;
                yaw = atan2(npcX, npcZ, playerX, playerZ);
 
                if (npc_test_move_taller_with_slipping(0, &x, &y, &z, length, yaw, npcHeight, 2.0f * npcRadius)) {
                    continue;
                }
            }
 
            if (length < minLength) {
                minLength = length;
                resultEncounter = encounter;
                resultNpc = npc;
                resultEnemy = enemy;
            }
        }
    }
 
    if (!(playerStatus->animFlags & PA_FLAG_8BIT_MARIO) && resultNpc != NULL && !is_picking_up_item()) {
        playerStatus->encounteredNPC = resultNpc;
        playerStatus->flags |= PS_FLAG_HAS_CONVERSATION_NPC;
        if (playerStatus->pressedButtons & BUTTON_A) {
            close_status_bar();
            gCurrentEncounter.hitType = ENCOUNTER_TRIGGER_CONVERSATION;
            resultEnemy->encountered = ENCOUNTER_TRIGGER_CONVERSATION;
            encounterStatus->curEncounter = resultEncounter;
            encounterStatus->curEnemy = resultEnemy;
            encounterStatus->firstStrikeType = FIRST_STRIKE_PLAYER;
            return TRUE;
        }
    }
    return FALSE;
}

Referenced by phys_peach_update(), and phys_update_action_state().

◆ clear_player_status()

void clear_player_status ( void )

Definition at line 807 of file 77480.c.

                               {
    mem_clear(&gPlayerStatus, sizeof(gPlayerStatus));
}

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

◆ clear_entity_models()

void clear_entity_models ( void )

Definition at line 51 of file entity_model.c.

                               {
    s32 i;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentEntityModelList = &gWorldEntityModelList;
    } else {
        gCurrentEntityModelList = &gBattleEntityModelList;
    }
 
    for (i = 0; i < MAX_ENTITY_MODELS; i++) {
        (*gCurrentEntityModelList)[i] = NULL;
    }
 
    gEntityModelCount = 0;
    entity_fog_enabled = 0;
    entity_fog_red = 10;
    entity_fog_green = 10;
    entity_fog_blue = 10;
    entity_fog_alpha = 10;
    entity_fog_dist_min = 800;
    entity_fog_dist_max = 1000;
}

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().

◆ bind_entity_model_setupGfx()

void bind_entity_model_setupGfx	(	s32	idx,
		void *	setupGfxCallbackArg0,
		void()(void )	fpSetupGfxCallback )

Definition at line 774 of file entity_model.c.

                                                                                                        {
    EntityModel* entityModel = (*gCurrentEntityModelList)[idx & ~BATTLE_ENTITY_ID_BIT];
 
    entityModel->fpSetupGfxCallback = fpSetupGfxCallback;
    entityModel->setupGfxCallbackArg0 = setupGfxCallbackArg0;
}

Referenced by render_entities(), render_shadows(), and show_immune_bonk().

◆ clear_animator_list()

void clear_animator_list ( void )

Definition at line 222 of file animator.c.

                               {
    s32 i;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentAnimMeshListPtr = &D_801539C0;
        for (i = 0; i < ARRAY_COUNT(D_801533C0); i++) {
            D_801533C0[i].ttl = -1;
        }
 
        for (i = 0; i < ARRAY_COUNT(D_801536C0); i++) {
            D_801536C0[i].ttl = -1;
        }
    } else {
        gCurrentAnimMeshListPtr = &D_80153A00;
    }
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentAnimMeshListPtr); i++) {
        (*gCurrentAnimMeshListPtr)[i] = NULL;
    }
 
    gAnimModelFogR = 10;
    gAnimModelFogG = 10;
    gAnimModelFogB = 10;
    gAnimModelFogA = 10;
    gAnimModelFogStart = 800;
    gAnimCount = 0;
    gAnimModelFogEnabled = 0;
    gAnimModelFogEnd = 1000;
}

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().

◆ clear_model_data()

void clear_model_data ( void )

Definition at line 2364 of file model.c.

                            {
    s32 i;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentModels = &wModelList;
        gCurrentTransformGroups = &wTransformGroups;
        gCurrentCustomModelGfxPtr = &wCustomModelGfx;
        gCurrentCustomModelGfxBuildersPtr = &wCustomModelGfxBuilders;
        gCurrentModelTreeRoot = &wModelTreeRoot;
        gCurrentModelLocalVtxBuffers = &wModelLocalVtxBuffers;
        gCurrentModelTreeNodeInfo = &wModelTreeNodeInfo;
        gBackgroundTintModePtr = &wBackgroundTintMode;
        ShroudTintAmt = 0;
        ShroudTintR = 0;
        ShroudTintG = 0;
        ShroudTintB = 0;
        gFogSettings = &wFogSettings;
    } else {
        gCurrentModels = &bModelList;
        gCurrentTransformGroups = &bTransformGroups;
        gCurrentCustomModelGfxPtr = &bCustomModelGfx;
        gCurrentCustomModelGfxBuildersPtr = &bCustomModelGfxBuilders;
        gCurrentModelTreeRoot = &bModelTreeRoot;
        gCurrentModelLocalVtxBuffers = &bModelLocalVtxBuffers;
        gCurrentModelTreeNodeInfo = &bModelTreeNodeInfo;
        gBackgroundTintModePtr = &bBackgroundTintMode;
        gFogSettings = &bFogSettings;
    }
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentModels); i++) {
        (*gCurrentModels)[i] = 0;
    }
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentTransformGroups); i++) {
        (*gCurrentTransformGroups)[i] = 0;
    }
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentCustomModelGfxPtr); i++) {
        (*gCurrentCustomModelGfxPtr)[i] = 0;
        (*gCurrentCustomModelGfxBuildersPtr)[i] = 0;
    }
 
    *gCurrentModelTreeRoot = NULL;
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentModelTreeNodeInfo); i++) {
        (*gCurrentModelTreeNodeInfo)[i].modelIndex = -1;
        (*gCurrentModelTreeNodeInfo)[i].treeDepth = 0;
        (*gCurrentModelTreeNodeInfo)[i].textureID = 0;
    }
 
    *gBackgroundTintModePtr = ENV_TINT_NONE;
    gFogSettings->enabled = FALSE;
    gFogSettings->color.r = 10;
    gFogSettings->color.g = 10;
    gFogSettings->color.b = 10;
    gFogSettings->color.a = 0;
    gFogSettings->startDistance = 950;
    gFogSettings->endDistance = 1000;
 
    for (i = 0; i < ARRAY_COUNT(texPannerAuxV); i++) {
        texPannerAuxV[i] = 0;
        texPannerAuxU[i] = 0;
        texPannerMainV[i] = 0;
        texPannerMainU[i] = 0;
    }
}

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

◆ init_sprite_shading_data()

void init_sprite_shading_data ( void )

Definition at line 39 of file sprite_shading.c.

                                    {
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gSpriteShadingProfile = &wSpriteShadingProfile;
        gAuxSpriteShadingProfile = &wSpriteShadingProfileAux;
    } else {
        gSpriteShadingProfile = &bSpriteShadingProfile;
        gAuxSpriteShadingProfile = &bSpriteShadingProfileAux;
    }
}

Referenced by clear_sprite_shading_data(), state_step_end_battle(), and state_step_unpause().

◆ clear_sprite_shading_data()

void clear_sprite_shading_data ( void )

Definition at line 20 of file sprite_shading.c.

                                     {
    s32 i;
 
    init_sprite_shading_data();
 
    for (i = 0; i < ARRAY_COUNT(gSpriteShadingProfile->sources); i++) {
        gSpriteShadingProfile->sources[i].flags = LIGHT_SOURCE_DISABLED;
        gAuxSpriteShadingProfile->sources[i].flags = LIGHT_SOURCE_DISABLED;
    }
 
    gSpriteShadingProfile->flags = 0;
    gSpriteShadingProfile->ambientColor.r = gSpriteShadingProfile->ambientColor.g = gSpriteShadingProfile->ambientColor.b = 50;
    gSpriteShadingProfile->ambientPower = 10;
 
    gAuxSpriteShadingProfile->flags = 0;
    gAuxSpriteShadingProfile->ambientColor.r = gAuxSpriteShadingProfile->ambientColor.g = gAuxSpriteShadingProfile->ambientColor.b = 50;
    gAuxSpriteShadingProfile->ambientPower = 20;
}

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

◆ clear_character_set()

void clear_character_set ( void )

Definition at line 192 of file msg.c.

                               {
    D_80155C98 = -1;
}

Referenced by load_engine_data().

◆ clear_trigger_data()

void clear_trigger_data ( void )

Definition at line 13 of file trigger.c.

                              {
    CollisionStatus* collisionStatus = &gCollisionStatus;
    s32 i;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentTriggerListPtr = &wTriggerList;
    } else {
        gCurrentTriggerListPtr = &bTriggerList;
    }
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentTriggerListPtr); i++) {
        (*gCurrentTriggerListPtr)[i] = NULL;
    }
 
    gTriggerCount = 0;
    collisionStatus->pushingAgainstWall = NO_COLLIDER;
    collisionStatus->curFloor = NO_COLLIDER;
    collisionStatus->lastTouchedFloor = NO_COLLIDER;
    collisionStatus->curCeiling = NO_COLLIDER;
    collisionStatus->curInspect = NO_COLLIDER;
    collisionStatus->unk_0C = -1;
    collisionStatus->unk_0E = -1;
    collisionStatus->unk_10 = -1;
    collisionStatus->curWall = NO_COLLIDER;
    collisionStatus->lastWallHammered = NO_COLLIDER;
    collisionStatus->touchingWallTrigger = 0;
    collisionStatus->bombetteExploded = -1;
    collisionStatus->bombetteExplosionPos.x = 0.0f;
    collisionStatus->bombetteExplosionPos.y = 0.0f;
    collisionStatus->bombetteExplosionPos.z = 0.0f;
}

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

◆ clear_script_list()

void clear_script_list ( void )

Definition at line 149 of file script_list.c.

                             {
    s32 i;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentScriptListPtr = &gWorldScriptList;
        gMapVars = gWorldMapVars;
        gMapFlags = gWorldMapFlags;
    } else {
        gCurrentScriptListPtr = &gBattleScriptList;
        gMapVars = gBattleMapVars;
        gMapFlags = gBattleMapFlags;
    }
 
    for (i = 0; i < MAX_SCRIPTS; i++) {
        (*gCurrentScriptListPtr)[i] = NULL;
    }
 
    gNumScripts = 0;
    gScriptListCount = 0;
    IsUpdatingScripts = FALSE;
 
    for (i = 0; i < MAX_MAPVARS; i++) {
        gMapVars[i] = 0;
    }
 
    for (i = 0; i < MAX_MAPFLAGS; i++) {
        gMapFlags[i] = 0;
    }
 
    clear_virtual_entity_list();
    reset_model_animators();
}

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

◆ clear_entity_data()

void clear_entity_data ( b32 arg0 )

Definition at line 787 of file entity.c.

                                 {
    s32 i;
 
    D_801516FC = 1;
    entity_numEntities = 0;
    entity_numShadows = 0;
    entity_updateCounter = 0;
    D_80151304 = 0;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gEntityHideMode = ENTITY_HIDE_MODE_0;
    }
 
    isAreaSpecificEntityDataLoaded = FALSE;
    gCurrentHiddenPanels.panelsCount = 0;
    gCurrentHiddenPanels.activateISpy = FALSE;
    if (!arg0) {
        D_80151344 = 0;
    }
    D_8014AFB0 = 255;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        wEntityDataLoadedSize = 0;
        for (i = 0; i < MAX_ENTITIES; i++) {
            wEntityBlueprint[i] = NULL;
        }
    } else {
        bEntityDataLoadedSize = 0;
        for (i = 0; i < ARRAY_COUNT(bEntityBlueprint); i++) {
            bEntityBlueprint[i] = NULL;
        }
    }
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gEntityHeapBottom = WORLD_ENTITY_HEAP_BOTTOM;
        gEntityHeapBase = WORLD_ENTITY_HEAP_BASE;
    } else {
        gEntityHeapBottom = (s32) BattleEntityHeapBottom;
        gEntityHeapBase = gEntityHeapBottom + 0x3000;
    }
 
    gCurrentEntityListPtr = get_entity_list();
    gCurrentShadowListPtr = get_shadow_list();
 
    for (i = 0; i < MAX_ENTITIES; i++) {
        (*gCurrentEntityListPtr)[i] = NULL;
    }
 
    for (i = 0; i < MAX_SHADOWS; i++) {
        (*gCurrentShadowListPtr)[i] = NULL;
    }
}

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().

◆ clear_effect_data()

void clear_effect_data ( void )

Definition at line 41 of file effects.c.

                             {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gEffectSharedData); i++) {
        gEffectSharedData[i].flags = 0;
    }
 
    for (i = 0; i < ARRAY_COUNT(gEffectInstances); i++) {
        gEffectInstances[i] = NULL;
    }
 
    osUnmapTLBAll();
    osMapTLB(EFFECT_GLOBALS_TLB_IDX, OS_PM_4K, effect_globals_VRAM, (s32)&gEffectGlobals & 0xFFFFFF, -1, -1);
    DMA_COPY_SEGMENT(effect_globals);
}

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

◆ clear_saved_variables()

void clear_saved_variables ( void )

Definition at line 5 of file vars_access.c.

                                 {
    SaveData* saveFile = &gCurrentSaveFile;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(saveFile->globalFlags); i++) {
        saveFile->globalFlags[i] = 0;
    }
 
    for (i = 0; i < ARRAY_COUNT(saveFile->globalBytes); i++) {
        saveFile->globalBytes[i] = 0;
    }
 
    for (i = 0; i < ARRAY_COUNT(saveFile->areaFlags); i++) {
        saveFile->areaFlags[i] = 0;
    }
 
    for (i = 0; i < ARRAY_COUNT(saveFile->areaBytes); i++) {
        saveFile->areaBytes[i] = 0;
    }
}

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

◆ clear_area_flags()

void clear_area_flags ( void )

Definition at line 26 of file vars_access.c.

                            {
    SaveData* saveFile = &gCurrentSaveFile;
    s32 i;
 
    if (gGameStatusPtr->didAreaChange) {
        for (i = 0; i < ARRAY_COUNT(saveFile->areaFlags); i++) {
            saveFile->areaFlags[i] = 0;
        }
 
        for (i = 0; i < ARRAY_COUNT(saveFile->areaBytes); i++) {
            saveFile->areaBytes[i] = 0;
        }
    }
}

Referenced by load_map_by_IDs().

◆ get_player_normal_pitch()

f32 get_player_normal_pitch ( void )

Definition at line 661 of file 43F0.c.

                                  {
    f32 traceNormalX = gGameStatusPtr->playerGroundTraceNormal.x;
    f32 traceNormalZ = gGameStatusPtr->playerGroundTraceNormal.z;
    f32 sqrt = sqrtf(SQ(traceNormalX) + SQ(traceNormalZ));
 
    return atan2(0.0f, 0.0f, sqrt, -gGameStatusPtr->playerGroundTraceNormal.y);
}

Referenced by phys_main_collision_below(), player_raycast_down(), and update_riding_physics().

◆ partner_kill_ability_script()

void partner_kill_ability_script ( void )

Definition at line 1109 of file partners.c.

                                       {
    NextPartnerCommand = PARTNER_CMD_ABORT;
 
    if (does_script_exist(wPartnerCurrentScriptID)) {
        kill_script_by_ID(wPartnerCurrentScriptID);
    }
}

◆ func_800EF3D4()

void func_800EF3D4 ( s32 arg0 )

Definition at line 2414 of file partners.c.

                             {
    D_8010CFCA = arg0;
}

Referenced by check_for_interactables(), entity_HiddenPanel_idle(), interact_inspect_dismiss(), update_encounters_conversation(), and update_encounters_neutral().

◆ mdl_update_transform_matrices()

void mdl_update_transform_matrices ( void )

Definition at line 2589 of file model.c.

                                         {
    Matrix4f tempModelMtx;
    Matrix4f tempGroupMtx;
    f32 mX, mY, mZ;
    f32 mtgX, mtgY, mtgZ;
    Model* model;
    Mtx* curMtx;
    ModelBoundingBox* bb;
    ModelTransformGroup* mtg;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentModels); i++) {
        model = (*gCurrentModels)[i];
        if (model != NULL && (model->flags != 0) && !(model->flags & MODEL_FLAG_INACTIVE)) {
            if (!(model->flags & MODEL_FLAG_MATRIX_DIRTY)) {
                if (model->matrixFreshness != 0) {
                    // matrix was recalculated recently and stored on the matrix stack
                    // since DisplayContexts alternate, we can fetch the previous matrix from the other context
                    model->matrixFreshness--;
                    if (model->matrixFreshness == 0) {
                        // since it hasn't changed in a few frames, cache the matrix
                        model->savedMtx = *model->finalMtx;
                    }
                    // copy matrix from previous DisplayContext stack to current one
                    curMtx = model->finalMtx;
                    model->finalMtx = &gDisplayContext->matrixStack[gMatrixListPos++];
                    *model->finalMtx = *curMtx;
                } else {
                    // transform matrix is not changed, have gfx build with saved matrix
                    model->finalMtx = &model->savedMtx;
                }
            } else {
                // first frame with dirty matrix, need to recalculate it
                model->flags &= ~MODEL_FLAG_MATRIX_DIRTY;
                model->matrixFreshness = 2;
 
                // write matrix to the matrix stack
                curMtx = &gDisplayContext->matrixStack[gMatrixListPos++];
                if (model->bakedMtx == NULL || (model->flags & MODEL_FLAG_TRANSFORM_GROUP_MEMBER)) {
                    guMtxF2L(model->userTransformMtx, curMtx);
                } else {
                    guMtxL2F(tempModelMtx, model->bakedMtx);
                    guMtxCatF(model->userTransformMtx, tempModelMtx, tempModelMtx);
                    guMtxF2L(tempModelMtx, curMtx);
                }
                model->flags &= ~MODEL_FLAG_IGNORE_MATRIX;
 
                // recalculate the center of the model with transformation applied
                bb = (ModelBoundingBox*) get_model_property(model->modelNode, MODEL_PROP_KEY_BOUNDING_BOX);
                mX = (bb->minX + bb->maxX) * 0.5f;
                mY = (bb->minY + bb->maxY) * 0.5f;
                mZ = (bb->minZ + bb->maxZ) * 0.5f;
                guMtxXFML(curMtx, mX, mY, mZ, &mX, &mY, &mZ);
                model->center.x = mX;
                model->center.y = mY;
                model->center.z = mZ;
 
                // point matrix for gfx building to our matrix on the stack
                model->finalMtx = curMtx;
 
                // disable bounds culling for models with dynamic transformations
                model->flags &= ~MODEL_FLAG_DO_BOUNDS_CULLING;
            }
        }
    }
 
    for (i = 0; i < ARRAY_COUNT((*gCurrentTransformGroups)); i++) {
        mtg = (*gCurrentTransformGroups)[i];
        if (mtg != NULL && mtg->flags != 0 && !(mtg->flags & TRANSFORM_GROUP_FLAG_INACTIVE)) {
            if (!(mtg->flags & TRANSFORM_GROUP_FLAG_MATRIX_DIRTY)) {
                if (mtg->matrixFreshness != 0) {
                    // matrix was recalculated recently and stored on the matrix stack
                    // since DisplayContexts alternate, we can fetch the previous matrix from the other context
                    mtg->matrixFreshness--;
                    if (mtg->matrixFreshness == 0) {
                        // since it hasn't changed in a few frames, cache the matrix
                        mtg->savedMtx = *mtg->finalMtx;
                    }
                    // copy matrix from previous DisplayContext stack to current one
                    curMtx = mtg->finalMtx;
                    mtg->finalMtx = &gDisplayContext->matrixStack[gMatrixListPos++];
                    *mtg->finalMtx = *curMtx;
                } else {
                    // transform matrix is not changed, have gfx build with saved matrix
                    mtg->finalMtx = &mtg->savedMtx;
                }
            } else {
                // first frame with dirty matrix, need to recalculate it
                mtg->flags &= ~TRANSFORM_GROUP_FLAG_MATRIX_DIRTY;
                mtg->matrixFreshness = 2;
 
                // write matrix to the matrix stack
                curMtx = &gDisplayContext->matrixStack[gMatrixListPos++];
                if (mtg->bakedMtx == NULL) {
                    guMtxF2L(mtg->userTransformMtx, curMtx);
                } else {
                    guMtxL2F(tempGroupMtx, mtg->bakedMtx);
                    guMtxCatF(mtg->userTransformMtx, tempGroupMtx, tempGroupMtx);
                    guMtxF2L(tempGroupMtx, curMtx);
                }
                mtg->flags &= ~TRANSFORM_GROUP_FLAG_IGNORE_MATRIX;
 
                // recalculate the center of the transform group with transformation applied
                bb = (ModelBoundingBox*) get_model_property(mtg->baseModelNode, MODEL_PROP_KEY_BOUNDING_BOX);
                mtgX = (bb->minX + bb->maxX) * 0.5f;
                mtgY = (bb->minY + bb->maxY) * 0.5f;
                mtgZ = (bb->minZ + bb->maxZ) * 0.5f;
                guMtxXFML(curMtx, mtgX, mtgY, mtgZ, &mtgX, &mtgY, &mtgZ);
                mtg->center.x = mtgX;
                mtg->center.y = mtgY;
                mtg->center.z = mtgZ;
 
                // point matrix for gfx building to our matrix on the stack
                mtg->finalMtx = curMtx;
            }
        }
    }
 
    build_custom_gfx();
}

Referenced by render_frame().

◆ mdl_group_set_custom_gfx()

void mdl_group_set_custom_gfx	(	u16	groupModelID,
		s32	customGfxIndex,
		s32	tintType,
		b32	invertSelection )

Definition at line 3694 of file model.c.

                                                                                                       {
    s32 maxGroupIndex = -1;
    s32 i;
    s32 minGroupIndex;
    s32 modelIndex = (*gCurrentModelTreeNodeInfo)[groupModelID].modelIndex;
    s32 siblingIndex;
    s32 maskLow, maskHigh, packed;
 
    if (modelIndex < MAX_MODELS - 1) {
        minGroupIndex = maxGroupIndex = modelIndex;
    } else {
        s32 treeDepth = (*gCurrentModelTreeNodeInfo)[groupModelID].treeDepth;
        for (i = groupModelID - 1; i >= 0; i--) {
            if ((*gCurrentModelTreeNodeInfo)[i].treeDepth <= treeDepth) {
                break;
            }
 
            siblingIndex = (*gCurrentModelTreeNodeInfo)[i].modelIndex;
 
            if (siblingIndex < MAX_MODELS - 1) {
                if (maxGroupIndex == -1) {
                    maxGroupIndex = siblingIndex;
                }
                minGroupIndex = siblingIndex;
            }
        }
    }
 
    maskLow = maskHigh = 0;
 
    if (customGfxIndex < 0) {
        maskLow = 0xF;
        customGfxIndex = 0;
    }
 
    if (tintType < 0) {
        maskHigh = 0xF0;
        tintType = 0;
    }
 
    packed = customGfxIndex + (tintType << 4);
 
    if (!invertSelection) {
        for (i = minGroupIndex; i <= maxGroupIndex; i++) {
            Model* model = (*gCurrentModels)[i];
            model->customGfxIndex = (model->customGfxIndex & (maskLow + maskHigh)) + packed;
        }
    } else {
        for (i = 0; i < minGroupIndex; i++) {
            Model* model = (*gCurrentModels)[i];
            model->customGfxIndex = (model->customGfxIndex & (maskLow + maskHigh)) + packed;
        }
        for (i = maxGroupIndex + 1; i < MAX_MODELS; i++) {
            Model* model = (*gCurrentModels)[i];
            if (model != NULL) {
                model->customGfxIndex = (model->customGfxIndex & (maskLow + maskHigh)) + packed;
            }
        }
    }
}

◆ backup_map_collision_data()

void backup_map_collision_data ( void )

Definition at line 80 of file collision.c.

                                     {
    CollisionData* collisionData;
    Collider* collider;
    ColliderBackupEntry* backupEntry;
    s32 i;
 
    collisionData = &gCollisionData;
    gCollisionDataBackup = general_heap_malloc(collisionData->numColliders * sizeof(ColliderBackupEntry));
    for (i = 0, backupEntry = gCollisionDataBackup; i < collisionData->numColliders; i++, backupEntry++) {
        collider = &collisionData->colliderList[i];
        backupEntry->flags = collider->flags;
        backupEntry->parentModelIndex = collider->parentModelIndex;
    }
 
    collisionData = &gZoneCollisionData;
    gCollisionDataZoneBackup = general_heap_malloc(collisionData->numColliders * sizeof(ColliderBackupEntry));
    for (i = 0, backupEntry = gCollisionDataZoneBackup; i < collisionData->numColliders; i++, backupEntry++) {
        collider = &collisionData->colliderList[i];
        backupEntry->flags = collider->flags;
        backupEntry->parentModelIndex = collider->parentModelIndex;
    }
 
    gZoneCollisionData.numColliders = 0;
}

Referenced by state_step_battle(), and state_step_pause().

◆ reset_status_bar()

void reset_status_bar ( void )

Definition at line 1682 of file inventory.c.

                            {
    PlayerData* playerData = &gPlayerData;
    StatusBar* statusBar = &gStatusBar;
    s32 i;
 
    statusBar->drawPosX = 12;
    statusBar->drawPosY = FULLY_RETRACTED_Y;
    statusBar->hidden = 0;
    statusBar->showTimer = 210;
    statusBar->unk_3B = FALSE;
    statusBar->ignoreChanges = FALSE;
    statusBar->openInputDisabled = FALSE;
    statusBar->alwaysShown = FALSE;
    statusBar->hpBlinking = BLINK_OFF;
    statusBar->hpBlinkAnimTime = 0;
    statusBar->hpBlinkTimeLeft = 0;
    statusBar->fpBlinking = BLINK_OFF;
    statusBar->fpBlinkAnimTime = 0;
    statusBar->fpBlinkTimeLeft = 0;
    statusBar->coinsBlinking = BLINK_OFF;
    statusBar->coinsBlinkAnimTime = 0;
    statusBar->coinsBlinkTimeLeft = 0;
    statusBar->starPowerBlinking = BLINK_OFF;
    statusBar->starPowerBlinkCounter = 0;
    statusBar->disabled = 0;
    statusBar->starpointsBlinking = BLINK_OFF;
    statusBar->starpointsBlinkAnimTime = 0;
    statusBar->prevIgnoreChanges = -1;
    statusBar->displayHP = playerData->curHP;
    statusBar->displayFP = playerData->curFP;
    statusBar->displayCoins = playerData->coins;
    statusBar->displayStarpoints = playerData->starPoints;
    statusBar->displayStarPower = playerData->starPower;
    statusBar->unk_3C = FALSE;
 
    for (i = 0; i < ARRAY_COUNT(statusBar->hpIconHIDs); i++) {
        copy_world_hud_element_ref_to_battle(statusBar->hpIconHIDs[i], statusBar->hpIconHIDs[i]);
    }
 
    for (i = 0; i < ARRAY_COUNT(statusBar->fpIconHIDs); i++) {
        copy_world_hud_element_ref_to_battle(statusBar->fpIconHIDs[i], statusBar->fpIconHIDs[i]);
    }
 
    copy_world_hud_element_ref_to_battle(statusBar->coinIconHID, statusBar->coinIconHID);
    copy_world_hud_element_ref_to_battle(statusBar->coinSparkleHID, statusBar->coinSparkleHID);
    copy_world_hud_element_ref_to_battle(statusBar->spIconHID, statusBar->spIconHID);
    copy_world_hud_element_ref_to_battle(statusBar->spShineHID, statusBar->spShineHID);
    copy_world_hud_element_ref_to_battle(statusBar->hpTimesHID, statusBar->hpTimesHID);
    copy_world_hud_element_ref_to_battle(statusBar->fpTimesHID, statusBar->fpTimesHID);
    copy_world_hud_element_ref_to_battle(statusBar->spTimesHID, statusBar->spTimesHID);
    copy_world_hud_element_ref_to_battle(statusBar->coinTimesHID, statusBar->coinTimesHID);
    copy_world_hud_element_ref_to_battle(statusBar->starIconHID, statusBar->starIconHID);
}

Referenced by state_step_battle(), and state_step_pause().

◆ btl_save_world_cameras()

void btl_save_world_cameras ( void )

Definition at line 1069 of file 16C8E0.c.

                                  {
    PlayerStatus* playerStatus = &gPlayerStatus;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(gCameras); i++) {
        SavedWorldCameras[i] = gCameras[i];
    }
 
    SavedWorldPlayerPosX = playerStatus->pos.x;
    SavedWorldPlayerPosY = playerStatus->pos.y;
    SavedWorldPlayerPosZ = playerStatus->pos.z;
    playerStatus->pos.x = NPC_DISPOSE_POS_X;
    playerStatus->pos.y = NPC_DISPOSE_POS_Y;
    playerStatus->pos.z = NPC_DISPOSE_POS_Z;
}

Referenced by state_step_battle().

◆ load_battle_section()

void load_battle_section ( void )

Definition at line 112 of file battle.c.

                               {
    BattleArea* battleArea = &gBattleAreas[UNPACK_BTL_AREA(gCurrentBattleID)];
    s32 battleIdx = UNPACK_BTL_INDEX(gCurrentBattleID);
 
    dma_copy(battleArea->dmaStart, battleArea->dmaEnd, battleArea->dmaDest);
 
    gCurrentBattlePtr = &(*battleArea->battles)[battleIdx];
 
    if (gCurrentStageID < 0) {
        gCurrentStagePtr = NULL;
    } else {
        gCurrentStagePtr = &(*battleArea->stages)[gCurrentStageID];
    }
 
    btl_set_state(BATTLE_STATE_NORMAL_START);
    gLastDrawBattleState = BATTLE_STATE_0;
}

Referenced by state_step_battle().

◆ btl_update()

void btl_update ( void )

Definition at line 254 of file 16C8E0.c.

                      {
    BattleStatus* battleStatus = &gBattleStatus;
    PlayerData* playerData = &gPlayerData;
    Actor* partner = battleStatus->partnerActor;
    f32 outAngle;
    f32 outMagnitude;
    s32 cond;
 
    if (battleStatus->inputBitmask != -1) {
        if ((battleStatus->flags1 & BS_FLAGS1_PARTNER_ACTING) && gGameStatusPtr->multiplayerEnabled) {
            s32 inputBitmask = battleStatus->inputBitmask;
 
            battleStatus->curButtonsDown = gGameStatusPtr->curButtons[1] & inputBitmask;
            battleStatus->curButtonsPressed = gGameStatusPtr->pressedButtons[1] & inputBitmask;
            battleStatus->curButtonsHeld = gGameStatusPtr->heldButtons[1] & inputBitmask;
            battleStatus->stickX = gGameStatusPtr->stickX[1];
            battleStatus->stickY = gGameStatusPtr->stickY[1];
        } else {
            s32 inputBitmask2 = battleStatus->inputBitmask;
 
            battleStatus->curButtonsDown = gGameStatusPtr->curButtons[0] & inputBitmask2;
            battleStatus->curButtonsPressed = gGameStatusPtr->pressedButtons[0] & inputBitmask2;
            battleStatus->curButtonsHeld = gGameStatusPtr->heldButtons[0] & inputBitmask2;
            battleStatus->stickX = gGameStatusPtr->stickX[0];
            battleStatus->stickY = gGameStatusPtr->stickY[0];
        }
    }
 
    get_stick_input_radial(&outAngle, &outMagnitude);
    battleStatus->stickAngle = outAngle;
    battleStatus->stickMagnitude = outMagnitude;
    battleStatus->pushInputBuffer[battleStatus->inputBufferPos] = battleStatus->curButtonsPressed;
    battleStatus->holdInputBuffer[battleStatus->inputBufferPos] = battleStatus->curButtonsDown;
 
    battleStatus->inputBufferPos++;
    if (battleStatus->inputBufferPos >= ARRAY_COUNT(battleStatus->pushInputBuffer)) {
        battleStatus->inputBufferPos = 0;
    }
 
    if (battleStatus->preUpdateCallback != NULL) {
        battleStatus->preUpdateCallback();
    }
 
    cond = TRUE;
    if (battleStatus->waitForState == BATTLE_STATE_0 || battleStatus->waitForState != gBattleState) {
        switch (gBattleState) {
            case BATTLE_STATE_NEGATIVE_1:
            case BATTLE_STATE_0:
                return;
            case BATTLE_STATE_NORMAL_START:
                btl_state_update_normal_start();
                cond = FALSE;
                break;
            case BATTLE_STATE_BEGIN_PLAYER_TURN:
                btl_state_update_begin_player_turn();
                break;
            case BATTLE_STATE_BEGIN_PARTNER_TURN:
                btl_state_update_begin_partner_turn();
                break;
            case BATTLE_STATE_9:
                btl_state_update_9();
                break;
            case BATTLE_STATE_BEGIN_TURN:
                btl_state_update_begin_turn();
                break;
            case BATTLE_STATE_END_TURN:
                btl_state_update_end_turn();
                break;
            case BATTLE_STATE_SWITCH_TO_PLAYER:
                btl_state_update_switch_to_player();
                break;
            case BATTLE_STATE_SWITCH_TO_PARTNER:
                btl_state_update_switch_to_partner();
                break;
            case BATTLE_STATE_PREPARE_MENU:
                btl_state_update_prepare_menu();
                break;
            case BATTLE_STATE_PLAYER_MENU:
                btl_state_update_player_menu();
                break;
            case BATTLE_STATE_PARTNER_MENU:
                btl_state_update_partner_menu();
                break;
            case BATTLE_STATE_TWINK_MENU:
                btl_state_update_twink_menu();
                break;
            case BATTLE_STATE_PEACH_MENU:
                btl_state_update_peach_menu();
                break;
            case BATTLE_STATE_SELECT_TARGET:
                btl_state_update_select_target();
                break;
            case BATTLE_STATE_PLAYER_MOVE:
                btl_state_update_player_move();
                break;
            case BATTLE_STATE_FIRST_STRIKE:
                btl_state_update_first_strike();
                break;
            case BATTLE_STATE_END_PLAYER_TURN:
                btl_state_update_end_player_turn();
                break;
            case BATTLE_STATE_END_PARTNER_TURN:
                btl_state_update_end_partner_turn();
                break;
            case BATTLE_STATE_ENEMY_MOVE:
                btl_state_update_enemy_move();
                break;
            case BATTLE_STATE_PARTNER_FIRST_STRIKE:
                btl_state_update_partner_striking_first();
                break;
            case BATTLE_STATE_NEXT_ENEMY:
                btl_state_update_next_enemy();
                break;
            case BATTLE_STATE_PARTNER_MOVE:
                btl_state_update_partner_move();
                break;
            case BATTLE_STATE_VICTORY:
                btl_state_update_victory();
                break;
            case BATTLE_STATE_END_BATTLE:
                btl_state_update_end_battle();
                break;
            case BATTLE_STATE_CHANGE_PARTNER:
                btl_state_update_change_partner();
                break;
            case BATTLE_STATE_RUN_AWAY:
                btl_state_update_run_away();
                break;
            case BATTLE_STATE_DEFEND:
                btl_state_update_defend();
                break;
            case BATTLE_STATE_DEFEAT:
                btl_state_update_defeat();
                break;
            case BATTLE_STATE_28:
                btl_state_update_1C();
                break;
            case BATTLE_STATE_END_TRAINING_BATTLE:
                btl_state_update_end_training_battle();
                break;
            case BATTLE_STATE_ENEMY_FIRST_STRIKE:
                btl_state_update_enemy_striking_first();
                break;
            case BATTLE_STATE_34:
                btl_state_update_22();
                break;
            case BATTLE_STATE_CELEBRATION:
                btl_state_update_celebration();
                break;
            case BATTLE_STATE_END_DEMO_BATTLE:
                btl_state_update_end_demo_battle();
                cond = FALSE;
                break;
        }
    }
 
    battleStatus->unk_90++;
    if (battleStatus->unk_90 == 40) {
        btl_bonk_cleanup();
    }
 
    update_damage_popups();
    update_action_ratings();
    update_health_bars();
    btl_popup_messages_update();
    update_nonplayer_actor_shadows();
 
    if (battleStatus->darknessMode != BTL_DARKNESS_STATE_LOCKED) {
        u8 paramType;
        f32 paramAmount;
 
        get_screen_overlay_params(SCREEN_LAYER_BACK, &paramType, &paramAmount);
 
        if (battleStatus->darknessMode > BTL_DARKNESS_STATE_NONE) {
            set_screen_overlay_color(SCREEN_LAYER_BACK, 0, 0, 0);
            if (partner == NULL) {
                set_screen_overlay_params_back(OVERLAY_SCREEN_COLOR, 215.0f);
            } else if (playerData->curPartner == PARTNER_WATT) {
                paramAmount -= 10.0f;
                if (paramAmount < 0.0f) {
                    paramAmount = 0.0f;
                }
                set_screen_overlay_params_back(OVERLAY_SCREEN_COLOR, paramAmount);
            } else {
                paramAmount += 10.0f;
                if (paramAmount > 215.0f) {
                    paramAmount = 215.0f;
                }
                set_screen_overlay_params_back(OVERLAY_SCREEN_COLOR, paramAmount);
            }
        } else if (battleStatus->darknessMode < BTL_DARKNESS_STATE_NONE) {
            paramAmount -= 10.0f;
            if (paramAmount < 0.0f) {
                paramAmount = 0.0f;
                set_screen_overlay_params_back(OVERLAY_NONE, -1.0f);
                battleStatus->darknessMode = BTL_DARKNESS_STATE_NONE;
            } else {
                set_screen_overlay_params_back(OVERLAY_SCREEN_COLOR, paramAmount);
            }
        }
 
        if (cond || D_802809F6 != -1) {
            if (D_802809F6 == -1) {
                if (gGameStatusPtr->demoState == DEMO_STATE_CHANGE_MAP) {
                    u8 paramType;
                    f32 paramAmount;
 
                    get_screen_overlay_params(SCREEN_LAYER_FRONT, &paramType, &paramAmount);
                    if (paramType == (u8) OVERLAY_NONE) {
                        D_802809F6 = 0;
                        set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, 0.0f);
                    }
                }
            } else if (D_802809F6 == 255) {
                if (gBattleState != BATTLE_STATE_END_DEMO_BATTLE) {
                    btl_set_state(BATTLE_STATE_END_DEMO_BATTLE);
                }
            } else {
                D_802809F6 += 10;
                if (D_802809F6 > 255) {
                    D_802809F6 = 255;
                }
 
                set_screen_overlay_params_front(OVERLAY_SCREEN_COLOR, D_802809F6);
                set_screen_overlay_color(SCREEN_LAYER_FRONT, 208, 208, 208);
                startup_set_fade_screen_alpha(255);
                startup_set_fade_screen_color(224);
            }
        }
    }
}

Referenced by state_step_battle().

◆ update_item_entities()

void update_item_entities ( void )

Definition at line 824 of file item_entity.c.

                                {
    ItemEntity* item;
    f32 x, y, z, hitDepth;
    s32 i;
 
    if (gOverrideFlags & (GLOBAL_OVERRIDES_400 | GLOBAL_OVERRIDES_800)) {
        return;
    }
 
    for (i = 0; i < MAX_ITEM_ENTITIES; i++) {
        item = gCurrentItemEntities[i];
 
        if (item != NULL && item->flags != 0) {
            if (item->itemID == ITEM_COIN) {
                if (rand_int(100) > 90) {
                    sparkle_script_init(item, &SparkleScript_Coin);
                    CoinSparkleCenterX = rand_int(16) - 8;
                    CoinSparkleCenterY = rand_int(16) - 8;
                    CoinSparkleCenterZ = 5;
                }
                sparkle_script_update(item);
            }
 
            item_entity_update(item);
 
            switch (item->spawnType) {
                case ITEM_SPAWN_MODE_KEY:
                    update_item_entity_stationary(item);
                    break;
                case ITEM_SPAWN_MODE_DECORATION:
                case ITEM_SPAWN_MODE_INVISIBLE:
                    update_item_entity_no_pickup(item);
                    break;
                case ITEM_SPAWN_MODE_TOSS_SPAWN_ALWAYS:
                case ITEM_SPAWN_MODE_FALL_SPAWN_ALWAYS:
                case ITEM_SPAWN_MODE_FIXED_SPAWN_ALWAYS:
                case ITEM_SPAWN_MODE_ITEM_BLOCK_SPAWN_ALWAYS:
                case ITEM_SPAWN_MODE_TOSS_FADE1:
                    update_item_entity_collectable(item);
                    break;
                case ITEM_SPAWN_AT_PLAYER:
                    update_item_entity_pickup(item);
                    break;
            }
 
            item = gCurrentItemEntities[i];
            if (item != NULL) {
                s32 xs, ys, zs;
 
                switch (item->spawnType) {
                    case ITEM_SPAWN_MODE_KEY:
                    case ITEM_SPAWN_MODE_TOSS_SPAWN_ALWAYS:
                    case ITEM_SPAWN_MODE_FALL_SPAWN_ALWAYS:
                    case ITEM_SPAWN_MODE_FIXED_SPAWN_ALWAYS:
                    case ITEM_SPAWN_AT_PLAYER:
                        xs = item->pos.x;
                        ys = item->pos.y;
                        zs = item->pos.z;
 
                        if (xs != item->lastPos.x || ys != item->lastPos.y || zs != item->lastPos.z) {
                            Shadow* shadow = get_shadow_by_index(item->shadowIndex);
 
                            x = item->pos.x;
                            y = item->pos.y + 12.0f;
                            z = item->pos.z;
                            hitDepth = 1000.0f;
                            npc_raycast_down_sides(COLLIDER_FLAG_IGNORE_NPC, &x, &y, &z, &hitDepth);
 
                            shadow->pos.x = x;
                            shadow->pos.y = y;
                            shadow->pos.z = z;
                            shadow->rot.x = gGameStatusPtr->playerGroundTraceAngles.x;
                            shadow->rot.y = 0.0f;
                            shadow->rot.z = gGameStatusPtr->playerGroundTraceAngles.z;
                            set_standard_shadow_scale(shadow, hitDepth * 0.5f);
                        }
                        break;
                }
                item->lastPos.x = item->pos.x;
                item->lastPos.y = item->pos.y;
                item->lastPos.z = item->pos.z;
            }
        }
    }
}

Referenced by state_step_battle(), and state_step_world().

◆ restore_map_collision_data()

void restore_map_collision_data ( void )

Definition at line 135 of file collision.c.

                                      {
    CollisionData* collisionData;
    Collider* collider;
    ColliderBackupEntry* backupEntry;
    s32 i;
 
    load_map_hit_asset();
 
    collisionData = &gCollisionData;
    for (i = 0, backupEntry = gCollisionDataBackup; i < collisionData->numColliders; i++, backupEntry++) {
        collider = &collisionData->colliderList[i];
        collider->flags = backupEntry->flags;
        collider->parentModelIndex = backupEntry->parentModelIndex;
 
        if (collider->flags != -1 && collider->flags & COLLIDER_FLAG_HAS_MODEL_PARENT) {
            parent_collider_to_model(i, collider->parentModelIndex);
            update_collider_transform(i);
        }
    }
 
    collisionData = &gZoneCollisionData;
    for (i = 0, backupEntry = gCollisionDataZoneBackup; i < collisionData->numColliders; i++, backupEntry++) {
        collider = &collisionData->colliderList[i];
        collider->flags = backupEntry->flags;
        collider->parentModelIndex = backupEntry->parentModelIndex;
    }
 
    general_heap_free(gCollisionDataBackup);
    general_heap_free(gCollisionDataZoneBackup);
}

Referenced by state_step_end_battle(), and state_step_unpause().

◆ mdl_load_all_textures()

void mdl_load_all_textures	(	struct ModelNode *	model,
		s32	romOffset,
		s32	size )

Definition at line 2322 of file model.c.

                                                                          {
    s32 baseOffset = 0;
 
    // textures are loaded to the upper half of the texture heap when not in the world
    if (gGameStatusPtr->context != CONTEXT_WORLD) {
        baseOffset = WORLD_TEXTURE_MEMORY_SIZE;
    }
 
    TextureHeapPos = TextureHeapBase + baseOffset;
 
    if (rootModel != NULL && romOffset != 0 && size != 0) {
        s32 i;
 
        for (i = 0; i < ARRAY_COUNT(TextureHandles); i++) {
            TextureHandles[i].gfx = NULL;
        }
 
        TreeIterPos = 0;
        if (rootModel != NULL) {
            load_next_model_textures(rootModel, romOffset, size);
        }
    }
}

Referenced by load_data_for_models(), state_init_file_select(), and state_step_end_battle().

◆ mdl_calculate_model_sizes()

void mdl_calculate_model_sizes ( void )

Definition at line 2455 of file model.c.

                                     {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentModels); i++) {
        Model* model = (*gCurrentModels)[i];
 
        if (model != NULL) {
            ModelBoundingBox* bb = (ModelBoundingBox*)get_model_property(model->modelNode, MODEL_PROP_KEY_BOUNDING_BOX);
 
            bb->halfSizeX = (bb->maxX - bb->minX) * 0.5;
            bb->halfSizeY = (bb->maxY - bb->minY) * 0.5;
            bb->halfSizeZ = (bb->maxZ - bb->minZ) * 0.5;
            model->flags |= MODEL_FLAG_MATRIX_DIRTY;
        }
    }
}

Referenced by state_step_end_battle(), and state_step_unpause().

Functions

Function Documentation

◆ fabsf()

◆ fabs()

◆ cosine()

◆ nuBoot()

◆ boot_idle()

◆ boot_main()

◆ is_debug_init()

◆ is_debug_panic()

◆ signF()

◆ func_8002ACDC()

◆ load_obfuscation_shims()

◆ heap_malloc()

◆ _heap_malloc()

◆ _heap_malloc_tail()

◆ _heap_free()

◆ _heap_realloc()

◆ _heap_create()

◆ dma_copy()

◆ rand_float()

◆ copy_matrix()

◆ get_shadow_by_index()

◆ get_time_freeze_mode()

◆ render_player_model()

◆ is_picking_up_item()

◆ integrate_gravity()

◆ gravity_use_fall_parms()

◆ get_clamped_angle_diff()

◆ startup_fade_screen_in()

◆ startup_fade_screen_out()

◆ startup_fade_screen_update()

◆ get_entity_type()

◆ get_entity_by_index()

◆ create_entity()

◆ entity_shattering_idle()

◆ show_damage_fx()

◆ entity_raycast_down()

◆ step_game_loop()

◆ resume_all_group()

◆ length2D()

◆ player_input_to_move_vector()

◆ game_input_to_move_vector()

◆ exec_ShakeCamX()

◆ exec_ShakeCam1()

◆ player_get_side_angle()

◆ draw_number()

◆ set_entity_model_flags()

◆ clear_entity_model_flags()

◆ exec_entity_model_commandlist()

◆ queue_render_task()

◆ create_mesh_animator()

◆ load_mesh_animator_tree()

◆ setup_pause_menu_tab()

◆ draw_ci_image_with_clipping()

◆ render_frame()

◆ clear_windows()

◆ update_window_hierarchy()

◆ get_msg_properties()

◆ replace_window_update()

◆ decode_yay0()

◆ ai_check_player_dist()

◆ pause_init()

◆ pause_handle_input()

◆ pause_cleanup()

◆ filemenu_init()

◆ filemenu_cleanup()

◆ filemenu_update()

◆ filemenu_get_exit_mode()

◆ filemenu_set_selected()

◆ filemenu_set_cursor_alpha()

◆ filemenu_set_cursor_goal_pos()

◆ filemenu_get_menu_message()

◆ gfx_task_background()

◆ update_enemy_shadows()

◆ update_hero_shadows()

◆ appendGfx_background_texture()

◆ appendGfx_enemy_actor()

◆ appendGfx_enemy_actor_blur()

◆ appendGfx_enemy_actor_reflection()