entity.c File Reference

Go to the source code of this file.

Macros
#define	WORLD_ENTITY_HEAP_BOTTOM   0x80250000
#define	WORLD_ENTITY_HEAP_BASE   0x80267FF0
#define	entity_jan_iwa_VRAM   (void*) 0x802BAE00
#define	entity_sbk_omo_VRAM   (void*) 0x802BAE00
#define	entity_default_VRAM   (void*) 0x802BAE00

Functions
void	update_shadows (void)
s32	step_entity_commandlist (Entity *entity)
void	entity_swizzle_anim_pointers (EntityBlueprint *entityData, void *baseAnim, void *baseGfx)
void	render_shadows (void)
void	update_entity_transform_matrix (Entity *entity)
void	update_shadow_transform_matrix (Shadow *shadow)
void	update_entity_inverse_rotation_matrix (Entity *entity)
void	delete_entity (s32 entityIndex)
void	delete_entity_and_unload_data (s32 entityIndex)
void	reload_world_entity_data (void)
s32	entity_get_collision_flags (Entity *entity)
void	entity_free_static_data (EntityBlueprint *data)
s32	create_entity_shadow (Entity *entity, f32 x, f32 y, f32 z)
void	update_entity_shadow_position (Entity *entity)
void	update_entities (void)
void	set_entity_commandlist (Entity *entity, s32 *entityScript)
void	exec_entity_commandlist (Entity *entity)
void	func_8010FD98 (void *arg0, s32 alpha)
void	func_8010FE44 (void *arg0)
void	entity_model_set_shadow_color (void *data)
void	render_entities (void)
Entity *	get_entity_by_index (s32 index)
Shadow *	get_shadow_by_index (s32 index)
EntityList *	get_entity_list (void)
ShadowList *	get_shadow_list (void)
s32	entity_start_script (Entity *entity)
u32	get_entity_type (s32 index)
void	delete_shadow (s32 shadowIndex)
s32	entity_try_partner_interaction_trigger (s32 entityIdx)
s32	test_player_entity_aabb (Entity *entity)
s32	is_player_action_state (s8 actionState)
void	entity_set_render_script (Entity *entity, EntityModelScript *cmdList)
void	entity_reset_collision (Entity *entity)
void	load_area_specific_entity_data (void)
void	clear_entity_data (b32 arg0)
void	init_entity_data (void)
s32	is_entity_data_loaded (Entity *entity, EntityBlueprint *blueprint, s32 *loadedStart, s32 *loadedEnd)
void	load_simple_entity_data (Entity *entity, EntityBlueprint *bp, s32 listIndex)
void	load_split_entity_data (Entity *entity, EntityBlueprint *entityData, s32 listIndex)
s32	func_80111790 (EntityBlueprint *data)
s32	create_entity (EntityBlueprint *bp,...)
s32	create_shadow_from_data (ShadowBlueprint *bp, f32 x, f32 y, f32 z)
s32	create_shadow_type (s32 type, f32 x, f32 y, f32 z)
b32	entity_raycast_down (f32 *x, f32 *y, f32 *z, f32 *hitYaw, f32 *hitPitch, f32 *hitLength)
	Mostly used for shadows.
void	set_standard_shadow_scale (Shadow *shadow, f32 height)
void	set_npc_shadow_scale (Shadow *shadow, f32 height, f32 npcRadius)
void	set_peach_shadow_scale (Shadow *shadow, f32 scale)
s32	is_block_on_ground (Entity *block)

Variables
s32	D_8014AFB0 = 255
s32	CreateEntityVarArgBuffer [4]
HiddenPanelsData	gCurrentHiddenPanels
s32	gEntityHideMode
s32	D_801512BC
s32	D_80151304
s32	D_80151344
s32	entity_numEntities
s32	gEntityHeapBase
s32	gLastCreatedEntityIndex
s32	gEntityHeapBottom
s32	entity_numShadows
s32	isAreaSpecificEntityDataLoaded
s32	entity_updateCounter
BSS EntityList	gWorldEntityList
BSS EntityList	gBattleEntityList
BSS EntityList *	gCurrentEntityListPtr
BSS ShadowList	gWorldShadowList
BSS ShadowList	gBattleShadowList
BSS ShadowList *	gCurrentShadowListPtr
BSS s32	wEntityDataLoadedSize
BSS s32	bEntityDataLoadedSize
BSS EntityBlueprint *	wEntityBlueprint [MAX_ENTITIES+2]
BSS EntityBlueprint *	bEntityBlueprint [4]
BSS s32	D_801516FC
Addr	BattleEntityHeapBottom

Macro Definition Documentation

WORLD_ENTITY_HEAP_BOTTOM

#define WORLD_ENTITY_HEAP_BOTTOM   0x80250000

Definition at line 17 of file entity.c.

Referenced by clear_entity_data(), and init_entity_data().

WORLD_ENTITY_HEAP_BASE

#define WORLD_ENTITY_HEAP_BASE   0x80267FF0

Definition at line 18 of file entity.c.

Referenced by clear_entity_data(), and init_entity_data().

entity_jan_iwa_VRAM

#define entity_jan_iwa_VRAM   (void*) 0x802BAE00

Definition at line 19 of file entity.c.

entity_sbk_omo_VRAM

#define entity_sbk_omo_VRAM   (void*) 0x802BAE00

Definition at line 20 of file entity.c.

entity_default_VRAM

#define entity_default_VRAM   (void*) 0x802BAE00

Definition at line 21 of file entity.c.

Function Documentation

update_shadows()

void update_shadows

(

void

)

Definition at line 203 of file entity.c.

                          {
    s32 i;
 
    entity_numShadows = 0;
 
    for (i = 0; i < MAX_SHADOWS; i++) {
        Shadow* shadow = get_shadow_by_index(i);
 
        if (shadow != nullptr) {
            entity_numShadows++;
 
            if (!(shadow->flags & ENTITY_FLAG_SKIP_UPDATE)) {
                if (shadow->flags & ENTITY_FLAG_ALWAYS_FACE_CAMERA) {
                    shadow->rot.y = -gCameras[gCurrentCameraID].curYaw;
                }
 
                update_shadow_transform_matrix(shadow);
 
                if (shadow->flags & ENTITY_FLAG_HAS_ANIMATED_MODEL) {
                    update_model_animator(shadow->entityModelID);
                } else {
                    exec_entity_model_commandlist(shadow->entityModelID);
                }
 
                if (shadow->flags & ENTITY_FLAG_PENDING_INSTANCE_DELETE) {
                    delete_shadow(shadow->listIndex);
                }
            }
        }
    }
}

Referenced by update_entities().

step_entity_commandlist()

s32 step_entity_commandlist

(

Entity *

entity

)

Definition at line 241 of file entity.c.

                                            {
    s32* args = entity->scriptReadPos;
    s32 ret;
    s32 labelId;
    void (*tempfunc)(Entity*);
 
    switch (*args++) {
        case ENTITY_SCRIPT_OP_End:
            entity->scriptDelay = -1;
            entity->updateScriptCallback = nullptr;
            entity->scriptReadPos = nullptr;
            ret = false;
            break;
        case ENTITY_SCRIPT_OP_Jump:
            entity->scriptReadPos = (s32*)*args;
            entity->scriptDelay = 1;
            entity->savedReadPos[0] = entity->scriptReadPos;
            ret = true;
            break;
        case ENTITY_SCRIPT_OP_Call:
            tempfunc = (void (*)(Entity*))(*args++);
            entity->scriptReadPos = args;
            (tempfunc)(entity);
            ret = true;
            break;
        case ENTITY_SCRIPT_OP_SetCallback:
            entity->scriptDelay = *args++;
            entity->updateScriptCallback = (s32 (*)(Entity*)) *args++;
            entity->scriptReadPos = args++;
            ret = false;
            break;
        case ENTITY_SCRIPT_OP_Goto:
            entity->scriptReadPos = entity->savedReadPos[*args];
            ret = true;
            break;
        case ENTITY_SCRIPT_OP_Label:
            labelId = *args++;
            entity->savedReadPos[labelId] = args;
            entity->scriptReadPos = args;
            ret = true;
            break;
        case ENTITY_SCRIPT_OP_RestartBoundScript:
            if (entity->boundScriptBytecode != nullptr) {
                entity->flags |= ENTITY_FLAG_BOUND_SCRIPT_DIRTY;
            }
            entity->scriptReadPos = args++;
            ret = true;
            break;
        case ENTITY_SCRIPT_OP_SetFlags:
            entity->flags |= *args++;
            entity->scriptReadPos = args++;
            ret = true;
            break;
        case ENTITY_SCRIPT_OP_ClearFlags:
            entity->flags &= ~*args++;
            entity->scriptReadPos = args++;
            ret = true;
            break;
        case ENTITY_SCRIPT_OP_PlaySound:
            sfx_play_sound(*args++);
            entity->scriptReadPos = args++;
            ret = true;
            break;
        default:
            args++;
            entity->scriptReadPos = args++;
            ret = true;
            break;
    }
    return ret;
}

Referenced by exec_entity_commandlist(), and update_entities().

entity_swizzle_anim_pointers()

void entity_swizzle_anim_pointers	(	EntityBlueprint *	entityData,
		void *	baseAnim,
		void *	baseGfx )

Definition at line 908 of file entity.c.

                                                                                              {
    StaticAnimatorNode* node;
    s32* ptr = (s32*)((s32)baseAnim + (s32)entityData->modelAnimationNodes);
 
    while (true) {
        if (*ptr == -1) {
            *ptr = 0;
            return;
        }
        node = (StaticAnimatorNode*)((s32)baseAnim + ((*ptr) & 0xFFFF));
        *ptr++ = (s32)node;
 
        if ((s32)node->displayList != -1) {
            node->displayList = (Gfx*)((s32)baseGfx + ((s32)(node->displayList) & 0xFFFF));
        } else {
            node->displayList = nullptr;
        }
 
        if ((s32)node->sibling != -1) {
            node->sibling = (StaticAnimatorNode*)((s32)baseAnim + ((s32)(node->sibling) & 0xFFFF));
        } else {
            node->sibling = nullptr;
        }
 
        if ((s32)node->child != -1) {
            node->child = (StaticAnimatorNode*)((s32)baseAnim + ((s32)(node->child) & 0xFFFF));
        } else {
            node->child = nullptr;
        }
 
        if ((s32)node->vtxList != -1) {
            node->vtxList = (Vtx*)((s32)baseGfx + ((s32)(node->vtxList) & 0xFFFFF));
        } else {
            node->vtxList = nullptr;
        }
    }
}

Referenced by load_split_entity_data(), and reload_world_entity_data().

render_shadows()

void render_shadows

(

void

)

Definition at line 424 of file entity.c.

                          {
    s32 i;
 
    for (i = 0; i < MAX_SHADOWS; i++) {
        Shadow* shadow = get_shadow_by_index(i);
 
        if (shadow != nullptr) {
            if (shadow->flags & ENTITY_FLAG_HIDDEN) {
                if (shadow->flags & ENTITY_FLAG_FADING_AWAY) {
                    shadow->alpha -= 20;
                    if (shadow->alpha <= 20) {
                        shadow->flags |= ENTITY_FLAG_PENDING_INSTANCE_DELETE;
                    }
                }
            } else if (shadow->flags & ENTITY_FLAG_HAS_ANIMATED_MODEL) {
                if (shadow->vertexArray == nullptr) {
                    render_animated_model(shadow->entityModelID, &shadow->transformMatrix);
                } else {
                    render_animated_model_with_vertices(shadow->entityModelID,
                                  &shadow->transformMatrix,
                                  shadow->vertexSegment,
                                  shadow->vertexArray);
                }
            } else {
                if (shadow->flags & ENTITY_FLAG_FADING_AWAY) {
                    shadow->alpha -= 20;
                    if (shadow->alpha <= 20) {
                        shadow->flags |=  ENTITY_FLAG_PENDING_INSTANCE_DELETE;
                    }
                }
 
                bind_entity_model_setupGfx(shadow->entityModelID, (void*)(u32)shadow->alpha, entity_model_set_shadow_color);
 
                if (shadow->vertexArray == nullptr) {
                    draw_entity_model_A(shadow->entityModelID, &shadow->transformMatrix);
                } else {
                    draw_entity_model_B(shadow->entityModelID,
                                           &shadow->transformMatrix,
                                           shadow->vertexSegment,
                                           shadow->vertexArray);
                }
            }
        }
    }
}

Referenced by render_entities().

update_entity_transform_matrix()

void update_entity_transform_matrix

(

Entity *

entity

)

Definition at line 470 of file entity.c.

                                                    {
    Matrix4f sp18;
    Matrix4f sp58;
    Matrix4f sp98;
    Matrix4f spD8;
    Matrix4f sp118;
    Matrix4f sp158;
    Matrix4f sp198;
 
    if (entity->updateMatrixOverride != nullptr) {
        entity->updateMatrixOverride(entity);
        return;
    }
 
    guTranslateF(sp58, entity->pos.x, entity->pos.y, entity->pos.z);
    guRotateF(spD8, entity->rot.x, 1.0f, 0.0f, 0.0f);
    guRotateF(sp118, entity->rot.y, 0.0f, 1.0f, 0.0f);
    guRotateF(sp158, entity->rot.z, 0.0f, 0.0f, 1.0f);
    guMtxCatF(sp158, spD8, sp18);
    guMtxCatF(sp18, sp118, sp98);
    guScaleF(sp198, entity->scale.x, entity->scale.y, entity->scale.z);
    guMtxCatF(sp198, sp98, sp18);
    guMtxCatF(sp18, sp58, sp98);
    guMtxF2L(sp98, &entity->transformMatrix);
}

Referenced by create_entity(), and update_entities().

update_shadow_transform_matrix()

void update_shadow_transform_matrix

(

Shadow *

shadow

)

Definition at line 496 of file entity.c.

                                                    {
    Matrix4f sp18;
    Matrix4f sp58;
    Matrix4f sp98;
    Matrix4f spD8;
    Matrix4f sp118;
    Matrix4f sp158;
    Matrix4f sp198;
 
    guTranslateF(sp58, shadow->pos.x, shadow->pos.y, shadow->pos.z);
    guRotateF(sp118, shadow->rot.x, 1.0f, 0.0f, 0.0f);
    guRotateF(spD8, shadow->rot.y, 0.0f, 1.0f, 0.0f);
    guRotateF(sp158, shadow->rot.z, 0.0f, 0.0f, 1.0f);
    guMtxCatF(sp158, sp118, sp98);
    guMtxCatF(spD8, sp98, sp98);
    guScaleF(sp198, shadow->scale.x, shadow->scale.y, shadow->scale.z);
    guMtxCatF(sp198, sp98, sp18);
    guMtxCatF(sp18, sp58, sp98);
    guMtxF2L(sp98, &shadow->transformMatrix);
}

Referenced by create_shadow_from_data(), and update_shadows().

update_entity_inverse_rotation_matrix()

void update_entity_inverse_rotation_matrix

(

Entity *

entity

)

Definition at line 517 of file entity.c.

                                                           {
    Matrix4f sp18;
    Matrix4f sp58;
 
    guRotateF(sp18, -entity->rot.y, 0.0f, 1.0f, 0.0f);
    guRotateF(sp58, -entity->rot.z, 0.0f, 0.0f, 1.0f);
    guMtxCatF(sp18, sp58, sp18);
    guRotateF(sp58, -entity->rot.x, 1.0f, 0.0f, 0.0f);
    guMtxCatF(sp18, sp58, entity->inverseTransformMatrix);
 
    entity->effectiveSize = sqrtf(((SQ(entity->aabb.x) + SQ(entity->aabb.z)) * 0.25f) + SQ(entity->aabb.y));
}

Referenced by update_entities().

delete_entity()

void delete_entity

(

s32

entityIndex

)

Definition at line 578 of file entity.c.

                                    {
    Entity* entity = get_entity_by_index(entityIndex);
 
    if (entity->dataBuf.any != nullptr) {
        heap_free(entity->dataBuf.any);
    }
 
    if (!(entity->flags & ENTITY_FLAG_HAS_ANIMATED_MODEL)) {
        free_entity_model_by_index(entity->virtualModelIndex);
    } else {
        delete_model_animator(get_animator_by_index(entity->virtualModelIndex));
    }
 
    if (entity->shadowIndex >= 0) {
        Shadow* shadow = get_shadow_by_index(entity->shadowIndex);
 
        shadow->flags |= ENTITY_FLAG_FADING_AWAY;
    }
 
    heap_free((*gCurrentEntityListPtr)[entityIndex]);
    (*gCurrentEntityListPtr)[entityIndex] = nullptr;
}

Referenced by update_entities().

delete_entity_and_unload_data()

void delete_entity_and_unload_data

(

s32

entityIndex

)

Definition at line 601 of file entity.c.

                                                    {
    Entity* entity = get_entity_by_index(entityIndex);
 
    if (entity->dataBuf.any != nullptr) {
        heap_free(entity->dataBuf.any);
    }
 
    if (!(entity->flags & ENTITY_FLAG_HAS_ANIMATED_MODEL)) {
        free_entity_model_by_index(entity->virtualModelIndex);
    } else {
        delete_model_animator(get_animator_by_index(entity->virtualModelIndex));
    }
 
    entity_free_static_data(entity->blueprint);
 
    if (entity->shadowIndex >= 0) {
        Shadow* shadow = get_shadow_by_index(entity->shadowIndex);
 
        shadow->flags |= ENTITY_FLAG_FADING_AWAY;
    }
 
    heap_free((*gCurrentEntityListPtr)[entityIndex]);
    (*gCurrentEntityListPtr)[entityIndex] = nullptr;
}

Referenced by update_entities().

reload_world_entity_data()

void reload_world_entity_data

(

void

)

Definition at line 860 of file entity.c.

                                    {
    s32 i;
    s32 totalSize = 0;
    s32 temp1;
    s32 dataLength;
    void* gfxData;
    void* animData;
 
    for (i = 0; i < MAX_ENTITIES; i++) {
        EntityBlueprint* bp = wEntityBlueprint[i];
        if (bp == nullptr) {
            break;
        }
 
        if (!(bp->flags & ENTITY_FLAG_HAS_ANIMATED_MODEL)) {
            void* gfxData;
 
            dataLength = ((bp->dma.end - bp->dma.start) >> 2);
            gfxData = (void*)(gEntityHeapBase - totalSize * 4 - dataLength * 4);
            totalSize += dma_copy(bp->dma.start, bp->dma.end, gfxData) >> 2;
        } else {
            DmaEntry* dmaList = bp->dmaList;
 
            if (bp->entityType == ENTITY_TYPE_RESET_MUNCHLESIA) {
                gfxData = (void*)gEntityHeapBottom;
                temp1 = dma_copy(dmaList[0].start, dmaList[0].end, gfxData) >> 2;
                dma_copy(dmaList[1].start, dmaList[1].end, (void*)(gEntityHeapBottom + temp1 * 4)) >> 2;
                animData = (void*)(gEntityHeapBottom + temp1 * 4);
                entity_swizzle_anim_pointers(bp, animData, gfxData);
            } else {
                s32 q;
 
                dataLength = ((dmaList[0].end - dmaList[0].start) >> 2);
                q = gEntityHeapBase - totalSize * 4;
                gfxData = (void*)(q - dataLength * 4);
                totalSize += dma_copy(dmaList[0].start, dmaList[0].end, gfxData) >> 2;
 
                dataLength = ((dmaList[1].end - dmaList[1].start) >> 2);
                q = gEntityHeapBase - totalSize * 4;
                animData = (void*)(q - dataLength * 4);
                totalSize += dma_copy(dmaList[1].start, dmaList[1].end, animData) >> 2;
 
                entity_swizzle_anim_pointers(bp, animData, gfxData);
            }
        }
    }
}

Referenced by init_entity_data().

entity_get_collision_flags()

s32 entity_get_collision_flags

(

Entity *

entity

)

Definition at line 634 of file entity.c.

                                               {
    u32 listIndex = entity->listIndex;
    s32 entityFlags = 0;
    u32 flag;
 
    if (entity->flags & ENTITY_FLAG_PARTNER_COLLISION) {
        entityFlags = ENTITY_COLLISION_PARTNER;
        entity->flags &= ~ENTITY_FLAG_PARTNER_COLLISION;
    }
 
    flag = gCollisionStatus.curFloor;
    if (flag != -1 && (flag & COLLISION_WITH_ENTITY_BIT) && listIndex == (u8)flag) {
        entityFlags |= ENTITY_COLLISION_PLAYER_TOUCH_FLOOR;
    }
 
    flag = gCollisionStatus.lastTouchedFloor;
    if (flag != -1 && (flag & COLLISION_WITH_ENTITY_BIT) && listIndex == (u8)flag) {
        entityFlags |= ENTITY_COLLISION_PLAYER_LAST_FLOOR;
    }
 
    flag = gCollisionStatus.curCeiling;
    if (flag != -1 && (flag & COLLISION_WITH_ENTITY_BIT) && listIndex == (u8)flag) {
        entityFlags |= ENTITY_COLLISION_PLAYER_TOUCH_CEILING;
    }
 
    flag = gCollisionStatus.pushingAgainstWall;
    if (flag != -1 && (flag & COLLISION_WITH_ENTITY_BIT) && listIndex == (u8)flag) {
        entityFlags |= ENTITY_COLLISION_PLAYER_PUSHING_AGAINST;
    }
 
    flag = gCollisionStatus.lastWallHammered;
    if (flag != -1 && (flag & COLLISION_WITH_ENTITY_BIT) && listIndex == (u8)flag) {
        entityFlags |= ENTITY_COLLISION_PLAYER_HAMMER;
    }
 
    flag = gCollisionStatus.curWall;
    if (flag != -1 && (flag & COLLISION_WITH_ENTITY_BIT) && listIndex == (u8)flag && gPlayerStatusPtr->pressedButtons & BUTTON_A) {
        entityFlags |= ENTITY_COLLISION_PLAYER_TOUCH_WALL;
    }
 
    return entityFlags;
}

Referenced by update_entities().

entity_free_static_data()

void entity_free_static_data

(

EntityBlueprint *

data

)

Definition at line 1158 of file entity.c.

                                                    {
    s32 freeSlot;
    s32 size;
    EntityBlueprint* bp;
 
    for (freeSlot = 0; freeSlot < MAX_ENTITIES; freeSlot++) {
        bp = wEntityBlueprint[freeSlot];
        if (bp == nullptr) {
            break;
        }
    }
 
    if (freeSlot < MAX_ENTITIES) {
        bp = wEntityBlueprint[freeSlot - 1];
        if (bp == data) {
            if (bp->flags & ENTITY_FLAG_HAS_ANIMATED_MODEL) {
                DmaEntry* dmaList = bp->dmaList;
                size = ((dmaList[0].end - dmaList[0].start) >> 2);
                size += ((dmaList[1].end - dmaList[1].start) >> 2);
                if (!func_80111790(bp)) {
                    wEntityBlueprint[freeSlot - 1] = nullptr;
                    wEntityDataLoadedSize -= size;
                }
            } else {
                size = (bp->dma.end - bp->dma.start) >> 2;
                if (!func_80111790(bp)) {
                    wEntityBlueprint[freeSlot - 1] = nullptr;
                    wEntityDataLoadedSize -= size;
                }
            }
        }
    }
}

Referenced by delete_entity_and_unload_data().

create_entity_shadow()

s32 create_entity_shadow	(	Entity *	entity,
		f32	x,
		f32	y,
		f32	z )

Definition at line 1506 of file entity.c.

                                                              {
    u16 bpFlags = entity->blueprint->flags;
    s32 type;
    s16 shadowIndex;
 
    if (bpFlags & ENTITY_FLAG_FIXED_SHADOW_SIZE) {
        type = (bpFlags & ENTITY_FLAG_CIRCULAR_SHADOW) ? SHADOW_FIXED_CIRCLE : SHADOW_FIXED_SQUARE;
    } else {
        type = (bpFlags & ENTITY_FLAG_CIRCULAR_SHADOW) ? SHADOW_VARYING_CIRCLE : SHADOW_VARYING_SQUARE;
    }
 
    shadowIndex = create_shadow_type(type, x, y, z);
    entity->shadowIndex = shadowIndex;
 
    get_shadow_by_index(shadowIndex)->flags |= ENTITY_FLAG_DARK_SHADOW | ENTITY_FLAG_SHADOW_POS_DIRTY;
 
    return entity->shadowIndex;
}

Referenced by create_entity().

update_entity_shadow_position()

void update_entity_shadow_position

(

Entity *

entity

)

Definition at line 1557 of file entity.c.

                                                   {
    Shadow* shadow = get_shadow_by_index(entity->shadowIndex);
 
    if (shadow != nullptr) {
        f32 rayX;
        f32 rayY;
        f32 rayZ;
        f32 hitYaw;
        f32 hitPitch;
        f32 hitLength;
        f32 origHitLength;
 
        if (entity->alpha < 255) {
            shadow->alpha = entity->alpha / 2;
        } else {
            u8 alphaTemp;
 
            if (shadow->flags & ENTITY_FLAG_DARK_SHADOW) {
                alphaTemp = 160;
            } else {
                alphaTemp = 128;
            }
            shadow->alpha = alphaTemp;
        }
 
        if (!(entity->flags & ENTITY_FLAG_HAS_DYNAMIC_SHADOW)) {
            if (shadow->flags & ENTITY_FLAG_SHADOW_POS_DIRTY) {
                shadow->flags &= ~ENTITY_FLAG_SHADOW_POS_DIRTY;
            } else {
                return;
            }
        }
 
        rayX = entity->pos.x;
        rayY = entity->pos.y;
        rayZ = entity->pos.z;
 
        if (!entity_raycast_down(&rayX, &rayY, &rayZ, &hitYaw, &hitPitch, &hitLength) && hitLength == 32767.0f) {
            hitLength = 0.0f;
        }
 
        origHitLength = hitLength;
 
        if (shadow->flags & ENTITY_FLAG_FIXED_SHADOW_SIZE) {
            hitLength = 212.5f;
            shadow->scale.x = entity->aabb.x / hitLength;
            shadow->scale.z = entity->aabb.z / hitLength;
        } else {
            hitLength = ((hitLength / 150.0f) + 0.95) * 250.0;
            shadow->scale.x = (entity->aabb.x / hitLength) * entity->scale.x;
            shadow->scale.z = (entity->aabb.z / hitLength) * entity->scale.z;
        }
 
        shadow->pos.x = entity->pos.x;
        shadow->pos.z = entity->pos.z;
        shadow->pos.y = rayY;
        entity->shadowPosY = rayY;
        shadow->rot.x = hitYaw;
        shadow->rot.z = hitPitch;
        shadow->rot.y = entity->rot.y;
 
        if (entity->pos.y < rayY) {
            shadow->flags |= ENTITY_FLAG_SKIP_UPDATE;
            entity->pos.y = rayY + 10.0f;
        } else {
            shadow->flags &= ~ENTITY_FLAG_SKIP_UPDATE;
        }
 
        shadow->flags = (shadow->flags & ~ENTITY_FLAG_HIDDEN) | ((u16)entity->flags & ENTITY_FLAG_HIDDEN);
        if (!(entity->flags & ENTITY_FLAG_400) && origHitLength == 0.0f) {
            shadow->flags |= ENTITY_FLAG_HIDDEN;
        }
    } else {
        entity->shadowPosY = 0.0f;
    }
}

Referenced by update_entities().

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 != nullptr) {
            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 != nullptr && 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 != nullptr) {
                        entity->updateScriptCallback(entity);
                    }
 
                    if (entity->scriptReadPos != nullptr) {
                        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().

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().

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().

func_8010FD98()

void func_8010FD98	(	void *	arg0,
		s32	alpha )

Definition at line 317 of file entity.c.

                                          {
    if (alpha >= 255) {
        gDPSetRenderMode(gMainGfxPos++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
        gDPSetCombineMode(gMainGfxPos++, G_CC_MODULATEIA, G_CC_MODULATEIA);
    } else {
        gDPSetCombineMode(gMainGfxPos++, PM_CC_01, PM_CC_02);
        gDPSetPrimColor(gMainGfxPos++, 0, 0, 0, 0, 0, alpha);
    }
}

Referenced by func_8010FE44().

func_8010FE44()

void func_8010FE44

(

void *

arg0

)

Definition at line 327 of file entity.c.

                               {
    func_8010FD98(arg0, D_8014AFB0);
}

Referenced by render_entities().

entity_model_set_shadow_color()

void entity_model_set_shadow_color

(

void *

data

)

Definition at line 331 of file entity.c.

                                               {
    s32 alpha = (s32)data;
 
    gDPSetCombineMode(gMainGfxPos++, PM_CC1_SHADOW, PM_CC2_SHADOW);
    gDPSetPrimColor(gMainGfxPos++, 0, 0, 0, 0, 0, alpha);
}

Referenced by render_shadows().

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 != nullptr) {
            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 != nullptr) {
                            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 == nullptr) {
                        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 != nullptr) {
                            bind_entity_model_setupGfx(
                                entity->virtualModelIndex,
                                (void*)(u32) entity->listIndex,
                                (void (*)(void*)) entity->renderSetupFunc
                            );
                        } else {
                            get_entity_model(entity->virtualModelIndex)->fpSetupGfxCallback = nullptr;
                        }
                    } else {
                        bind_entity_model_setupGfx(entity->virtualModelIndex, (void*)(u32)entity->listIndex, func_8010FE44);
                    }
 
                    if (entity->gfxBaseAddr == nullptr) {
                        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().

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().

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_entity_list()

EntityList * get_entity_list

(

void

)

Definition at line 538 of file entity.c.

                                  {
    EntityList* ret;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        ret = &gWorldEntityList;
    } else {
        ret = &gBattleEntityList;
    }
    return ret;
}

Referenced by clear_entity_data(), and init_entity_data().

get_shadow_list()

ShadowList * get_shadow_list

(

void

)

Definition at line 549 of file entity.c.

                                  {
    ShadowList* ret;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        ret = &gWorldShadowList;
    } else {
        ret = &gBattleShadowList;
    }
    return ret;
}

Referenced by clear_entity_data(), and init_entity_data().

entity_start_script()

s32 entity_start_script

(

Entity *

entity

)

Definition at line 560 of file entity.c.

                                        {
    if (entity->boundScriptBytecode != nullptr) {
        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().

get_entity_type()

u32 get_entity_type

(

s32

index

)

Definition at line 568 of file entity.c.

                               {
    Entity* entity = get_entity_by_index(index);
 
    if (entity == nullptr) {
        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().

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] = nullptr;
}

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().

entity_try_partner_interaction_trigger()

s32 entity_try_partner_interaction_trigger

(

s32

entityIdx

)

Definition at line 677 of file entity.c.

                                                          {
    s32 interacted = false;
    u32 entityType = get_entity_type(entityIdx);
    s32 partnerID = get_current_partner_id();
    Entity* entity;
 
    switch (partnerID) {
        case PARTNER_BOMBETTE:
            switch (entityType) {
                default:
                    return false;
                case ENTITY_TYPE_BLUE_SWITCH:
                case ENTITY_TYPE_RED_SWITCH:
                case ENTITY_TYPE_MULTI_TRIGGER_BLOCK:
                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:
                case ENTITY_TYPE_HAMMER1_BLOCK:
                case ENTITY_TYPE_HAMMER1_BLOCK_TINY:
                case ENTITY_TYPE_SUPER_BLOCK:
                case ENTITY_TYPE_BOMBABLE_ROCK:
                    entity = get_entity_by_index(entityIdx);
                    entity->flags |= ENTITY_FLAG_PARTNER_COLLISION;
                    interacted = true;
            }
            break;
        case PARTNER_KOOPER:
             switch (entityType) {
                default:
                    return false;
                case ENTITY_TYPE_BLUE_SWITCH:
                case ENTITY_TYPE_RED_SWITCH:
                case ENTITY_TYPE_MULTI_TRIGGER_BLOCK:
                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:
                case ENTITY_TYPE_HEALING_BLOCK:
                case ENTITY_TYPE_1C:
                case ENTITY_TYPE_SAVE_POINT:
                case ENTITY_TYPE_SUPER_BLOCK:
                    entity = get_entity_by_index(entityIdx);
                    entity->flags |= ENTITY_FLAG_PARTNER_COLLISION;
                    interacted = true;
            }
            break;
    }
    return interacted;
}

Referenced by blast_affect_entities(), lateral_hit_interactable_entity(), and vertical_hit_interactable_entity().

test_player_entity_aabb()

s32 test_player_entity_aabb

(

Entity *

entity

)

Definition at line 734 of file entity.c.

                                            {
    f32 yTemp = entity->pos.y - (gPlayerStatus.pos.y + gPlayerStatus.colliderHeight);
    f32 xCollRadius;
    f32 zCollRadius;
    f32 xDist;
    f32 zDist;
 
    if (yTemp > 0.0f || gPlayerStatus.colliderHeight + entity->aabb.y < fabsf(yTemp)) {
        return 0;
    }
 
    xCollRadius = (gPlayerStatus.colliderDiameter + entity->aabb.x) * 0.5;
    xDist = fabsf(gPlayerStatus.pos.x - entity->pos.x);
    zCollRadius = ((gPlayerStatus.colliderDiameter + entity->aabb.z) * 0.5);
    zDist = fabsf(gPlayerStatus.pos.z - entity->pos.z);
 
    if (xCollRadius < xDist || zCollRadius < zDist) {
        return 0;
    }
 
    return 1;
}

is_player_action_state()

s32 is_player_action_state

(

s8

actionState

)

Definition at line 757 of file entity.c.

                                           {
    return actionState == gPlayerStatus.actionState;
}

entity_set_render_script()

void entity_set_render_script	(	Entity *	entity,
		EntityModelScript *	cmdList )

Definition at line 761 of file entity.c.

                                                                          {
    if (!(entity->flags & ENTITY_FLAG_HAS_ANIMATED_MODEL)) {
        set_entity_model_render_command_list(entity->virtualModelIndex, cmdList);
    }
}

Referenced by Entity_BoardedFloor_shatter(), entity_HeartBlock_change_render_script(), entity_HeartBlockContent__anim_heal(), entity_HeartBlockContent_reset(), entity_HiddenPanel_init(), and entity_WoodenCrate_idle().

entity_reset_collision()

void entity_reset_collision

(

Entity *

entity

)

Definition at line 767 of file entity.c.

                                            {
    entity->collisionTimer = 0;
    entity->flags &= ~ENTITY_FLAG_DETECTED_COLLISION;
}

load_area_specific_entity_data()

void load_area_specific_entity_data

(

void

)

Definition at line 772 of file entity.c.

                                          {
    //TODO hardcoded map and area IDs, connect these to MapTable.xml eventually
    if (!isAreaSpecificEntityDataLoaded) {
        if (gGameStatusPtr->areaID == AREA_JAN || gGameStatusPtr->areaID == AREA_IWA) {
            DMA_COPY_SEGMENT(entity_jan_iwa);
        } else if (gGameStatusPtr->areaID == AREA_SBK || gGameStatusPtr->areaID == AREA_OMO) {
            DMA_COPY_SEGMENT(entity_sbk_omo);
        } else {
            DMA_COPY_SEGMENT(entity_default);
        }
 
        isAreaSpecificEntityDataLoaded = true;
    }
}

Referenced by create_entity().

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] = nullptr;
        }
    } else {
        bEntityDataLoadedSize = 0;
        for (i = 0; i < ARRAY_COUNT(bEntityBlueprint); i++) {
            bEntityBlueprint[i] = nullptr;
        }
    }
 
    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] = nullptr;
    }
 
    for (i = 0; i < MAX_SHADOWS; i++) {
        (*gCurrentShadowListPtr)[i] = nullptr;
    }
}

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

init_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().

is_entity_data_loaded()

s32 is_entity_data_loaded	(	Entity *	entity,
		EntityBlueprint *	blueprint,
		s32 *	loadedStart,
		s32 *	loadedEnd )

Definition at line 946 of file entity.c.

                                                                                                        {
    EntityBlueprint** blueprints;
    s32 i;
    s32 ret;
    DmaEntry* entDmaList;
 
    *loadedStart = 0;
    *loadedEnd = 0;
    ret = false;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        blueprints = wEntityBlueprint;
    } else {
        blueprints = bEntityBlueprint;
    }
 
    for (i = 0; i < MAX_ENTITIES; i++, blueprints++) {
        EntityBlueprint* bp = *blueprints;
        if (bp == nullptr) {
            blueprints[0] = blueprint;
            blueprints[1] = nullptr;
            ret = true;
            if (blueprint->flags & ENTITY_FLAG_HAS_ANIMATED_MODEL) {
                s32 size;
                entDmaList = blueprint->dmaList;
                size = (entDmaList[0].end - entDmaList[0].start) >> 2;
                *loadedEnd = *loadedStart + size;
            }
            break;
        } else {
            DmaEntry* bpDmaList = bp->dmaList;
            entDmaList = blueprint->dmaList;
            if (bpDmaList == entDmaList) {
                if (blueprint->flags & ENTITY_FLAG_HAS_ANIMATED_MODEL) {
                    s32 size = (bpDmaList[0].end - bpDmaList[0].start) >> 2;
                    *loadedEnd = *loadedStart + size;
                }
                break;
            } else if (bp == blueprint) {
                if (bp->flags & ENTITY_FLAG_HAS_ANIMATED_MODEL) {
                    s32 size = (entDmaList[0].end - entDmaList[0].start) >> 2;
                    *loadedEnd = *loadedStart + size;
                }
                break;
            } else {
                if (bp->flags & ENTITY_FLAG_HAS_ANIMATED_MODEL) {
                    s32 size = (bpDmaList[0].end - bpDmaList[0].start) >> 2;
                    *loadedEnd = *loadedStart = *loadedStart + size;
                    size = (bpDmaList[1].end - bpDmaList[1].start) >> 2;
                    *loadedStart = *loadedStart + size;
                } else {
                    *loadedStart += (bp->dma.end - bp->dma.start) >> 2;
                }
            }
        }
    }
 
    return ret;
}

Referenced by load_simple_entity_data(), and load_split_entity_data().

load_simple_entity_data()

void load_simple_entity_data	(	Entity *	entity,
		EntityBlueprint *	bp,
		s32	listIndex )

Definition at line 1006 of file entity.c.

                                                                                 {
    s32 loadedStart;
    s32 loadedEnd;
    s32 entitySize;
    s32 totalSize;
 
    entity->vertexSegment = 0xA;
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        totalSize = wEntityDataLoadedSize;
    } else {
        totalSize = bEntityDataLoadedSize;
    }
 
    if (is_entity_data_loaded(entity, bp, &loadedStart, &loadedEnd)) {
        if (totalSize + ((bp->dma.end - bp->dma.start) >> 2) > 0x5FFCU) {
            get_entity_type(entity->listIndex);
            get_entity_type(entity->listIndex);
            PANIC();
        }
        entitySize = (bp->dma.end - bp->dma.start) >> 2;
        entity->gfxBaseAddr = (void*)(gEntityHeapBase - totalSize * 4 - entitySize * 4);
        totalSize += dma_copy(bp->dma.start, bp->dma.end, entity->gfxBaseAddr) >> 2;
        get_entity_type(entity->listIndex);
    } else {
        entitySize = (bp->dma.end - bp->dma.start) >> 2;
        entity->gfxBaseAddr = (void*)(gEntityHeapBase - loadedStart * 4 - entitySize * 4);
        get_entity_type(entity->listIndex);
    }
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        wEntityDataLoadedSize = totalSize;
    } else {
        bEntityDataLoadedSize = totalSize;
    }
}

Referenced by create_entity().

load_split_entity_data()

void load_split_entity_data	(	Entity *	entity,
		EntityBlueprint *	entityData,
		s32	listIndex )

Definition at line 1042 of file entity.c.

                                                                                        {
    s32 swizzlePointers = false;
    s32 loadedStart, loadedEnd;
    void* animBaseAddr;
    s16* animationScript;
    StaticAnimatorNode** animationNodes;
    s32 specialSize;
    s32 dma1size;
    s32 dma2size_1;
    s32 dma2size_2;
    s32 totalLoaded;
 
    if (entityData->flags & ENTITY_FLAG_HAS_ANIMATED_MODEL) {
        DmaEntry* dmaList = entityData->dmaList;
        entity->vertexSegment = 0xA;
 
        switch (entityData->entityType) {
            case ENTITY_TYPE_RESET_MUNCHLESIA:
            case ENTITY_TYPE_MUNCHLESIA_ENVELOP:
            case ENTITY_TYPE_MUNCHLESIA_CHEWING:
            case ENTITY_TYPE_MUNCHLESIA_RESET1:
                specialSize = 0x1000;
                break;
            case ENTITY_TYPE_MUNCHLESIA_GRAB:
            case ENTITY_TYPE_MUNCHLESIA_BEGIN_CHEW:
            case ENTITY_TYPE_MUNCHLESIA_SPIT_OUT:
            case ENTITY_TYPE_MUNCHLESIA_RESET2:
                specialSize = 0x2BC0;
                break;
            default:
                specialSize = 0;
                break;
        }
 
        if (specialSize != 0) {
            if (entityData->entityType == ENTITY_TYPE_RESET_MUNCHLESIA) {
                is_entity_data_loaded(entity, entityData, &loadedStart, &loadedEnd);
            }
            specialSize -= 0x1000;
 
            dma1size = dma_copy(dmaList[0].start, dmaList[0].end, (void*)(gEntityHeapBottom + specialSize * 4)) / 4;
            entity->gfxBaseAddr = (void*)(gEntityHeapBottom + specialSize * 4);
            dma_copy(dmaList[1].start, dmaList[1].end, (void*)(gEntityHeapBottom + specialSize * 4 + dma1size * 4));
            animBaseAddr = (void*)(gEntityHeapBottom + specialSize * 4 + dma1size * 4);
            swizzlePointers = true;
        } else if (is_entity_data_loaded(entity, entityData, &loadedStart, &loadedEnd)) {
            if (gGameStatusPtr->context == CONTEXT_WORLD) {
                totalLoaded = wEntityDataLoadedSize;
            } else {
                totalLoaded = bEntityDataLoadedSize;
            }
 
            if ((totalLoaded + ((dmaList[0].end - dmaList[0].start) >> 2)) > 0x5FFCU) {
                get_entity_type(entity->listIndex);
                PANIC();
            }
 
            if ((totalLoaded + ((dmaList[1].end - dmaList[1].start) >> 2)) > 0x5FFCU) {
                get_entity_type(entity->listIndex);
                PANIC();
            }
 
            dma2size_1 = dma_copy(dmaList[0].start, dmaList[0].end, dmaList[0].start + ((gEntityHeapBase - totalLoaded * 4 - (s32)dmaList[0].end) >> 2) * 4) >> 2;
            entity->gfxBaseAddr = (void*)(gEntityHeapBase - totalLoaded * 4 - dma2size_1 * 4);
            totalLoaded += dma2size_1;
 
            dma2size_2 = dma_copy(dmaList[1].start, dmaList[1].end, dmaList[1].start + ((gEntityHeapBase - totalLoaded * 4 - (s32)dmaList[1].end) >> 2) * 4) >> 2;
            animBaseAddr = (void*)(gEntityHeapBase - totalLoaded * 4 - dma2size_2 * 4);
            totalLoaded += dma2size_2;
            get_entity_type(entity->listIndex);
 
            if (gGameStatusPtr->context == CONTEXT_WORLD) {
                wEntityDataLoadedSize = totalLoaded;
            } else {
                bEntityDataLoadedSize = totalLoaded;
            }
            swizzlePointers = true;
        } else {
            u32 temp = (dmaList[0].end - dmaList[0].start) >> 2;
            entity->gfxBaseAddr = (void*)(gEntityHeapBase - loadedStart * 4 - temp * 4);
            temp = (dmaList[1].end - dmaList[1].start) >> 2;
            animBaseAddr = (void*)(gEntityHeapBase - loadedEnd * 4 - temp * 4);
            get_entity_type(entity->listIndex);
        }
    } else {
        entity->virtualModelIndex = create_model_animator(entityData->renderCommandList);
        load_model_animator_tree(entity->virtualModelIndex, entityData->modelAnimationNodes);
        update_model_animator(entity->virtualModelIndex);
        return;
    }
    animationScript = entityData->renderCommandList;
    animationNodes = (StaticAnimatorNode**)((s32)animBaseAddr + (s32)entityData->modelAnimationNodes);
    if (swizzlePointers) {
        entity_swizzle_anim_pointers(entityData, animBaseAddr, entity->gfxBaseAddr);
    }
    entity->virtualModelIndex = create_mesh_animator(animationScript, animBaseAddr);
    load_mesh_animator_tree(entity->virtualModelIndex, animationNodes);
    update_model_animator(entity->virtualModelIndex);
    entity->flags |= ENTITY_FLAG_HAS_ANIMATED_MODEL;
}

Referenced by create_entity().

func_80111790()

s32 func_80111790

(

EntityBlueprint *

data

)

Definition at line 1143 of file entity.c.

                                         {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentEntityListPtr); i++) {
        Entity* entity = (*gCurrentEntityListPtr)[i];
 
        if (entity != nullptr && entity->blueprint->dma.start != nullptr) {
            if (entity->blueprint->dma.start == entity->blueprint) {
                return true;
            }
        }
    }
    return false;
}

Referenced by entity_free_static_data().

create_entity()

s32 create_entity	(	EntityBlueprint *	bp,
			... )

Definition at line 1192 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] == nullptr) {
            break;
        }
    }
 
    if (listIndex >= MAX_ENTITIES) {
        return -1;
    }
 
    (*gCurrentEntityListPtr)[listIndex] = entity = heap_malloc(sizeof(*entity));
    mem_clear(entity, sizeof(*entity));
    entity->dataBuf.any = nullptr;
    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 = nullptr;
    entity->updateMatrixOverride = nullptr;
    entity->blueprint = bp;
    entity->scriptReadPos = bp->updateEntityScript;
    entity->scriptDelay = entity->scriptReadPos != nullptr ? 1 : 0;
    entity->savedReadPos[0] = bp->updateEntityScript;
    entity->updateScriptCallback = nullptr;
    entity->flags = bp->flags | ENTITY_FLAG_CREATED;
    entity->collisionFlags = 0;
    entity->collisionTimer = 0;
    entity->renderSetupFunc = nullptr;
    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 = nullptr;
 
    if (!(bp->flags & ENTITY_FLAG_HAS_ANIMATED_MODEL)) {
        if (bp->dma.start != 0) {
            load_simple_entity_data(entity, bp, listIndex);
        }
        if (bp->renderCommandList != nullptr) {
            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 != nullptr) {
        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().

create_shadow_from_data()

s32 create_shadow_from_data	(	ShadowBlueprint *	bp,
		f32	x,
		f32	y,
		f32	z )

Definition at line 1307 of file entity.c.

                                                                      {
    Shadow* shadow;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentShadowListPtr); i++) {
        if ((*gCurrentShadowListPtr)[i] == nullptr) {
            break;
        }
    }
 
    ASSERT(i < ARRAY_COUNT(*gCurrentShadowListPtr));
 
    shadow = heap_malloc(sizeof(*shadow));
    (*gCurrentShadowListPtr)[i] = shadow;
    mem_clear(shadow, sizeof(*shadow));
    shadow->listIndex = i;
    shadow->flags = bp->flags | ENTITY_FLAG_CREATED;
    shadow->alpha = 128;
    shadow->unk_06 = 0x80;
    shadow->pos.x = x;
    shadow->pos.y = y;
    shadow->pos.z = z;
    shadow->scale.x = 1.0f;
    shadow->scale.y = 1.0f;
    shadow->scale.z = 1.0f;
 
    if (bp->animModelNode != nullptr) {
        shadow->flags |= ENTITY_FLAG_HAS_ANIMATED_MODEL;
        shadow->entityModelID = create_model_animator(bp->renderCommandList);
        load_model_animator_tree(shadow->entityModelID, bp->animModelNode);
    } else {
        shadow->entityModelID = load_entity_model(bp->renderCommandList);
    }
 
    if (bp->onCreateCallback != nullptr) {
        bp->onCreateCallback(shadow);
    }
    update_shadow_transform_matrix(shadow);
    return shadow->listIndex;
}

Referenced by create_shadow_type().

create_shadow_type()

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

Definition at line 1525 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().

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 1634 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().

set_standard_shadow_scale()

void set_standard_shadow_scale	(	Shadow *	shadow,
		f32	height )

Definition at line 1671 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 1684 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_peach_shadow_scale()

void set_peach_shadow_scale	(	Shadow *	shadow,
		f32	scale )

Definition at line 1702 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 1733 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().

Variable Documentation

D_8014AFB0

s32 D_8014AFB0 = 255

Definition at line 33 of file entity.c.

Referenced by clear_entity_data(), func_8010FE44(), and render_entities().

CreateEntityVarArgBuffer

s32 CreateEntityVarArgBuffer[4]

Definition at line 35 of file entity.c.

Referenced by create_entity(), entity_ArrowSign_init(), entity_BlueSwitch_init(), entity_Chest_readargs(), entity_HeartBlock_create_child_entity(), entity_HiddenPanel_init(), entity_init_BlueWarpPipe(), entity_ItemBlock_init(), entity_SimpleSpring_init(), entity_SpinningFlower_init(), entity_Tweester_init(), and entity_WoodenCrate_init().

gCurrentHiddenPanels

HiddenPanelsData gCurrentHiddenPanels

Definition at line 36 of file entity.c.

Referenced by action_hammer_end_swing(), action_update_spin_jump(), action_update_tornado_jump(), check_for_ispy(), clear_entity_data(), entity_HiddenPanel_idle(), entity_HiddenPanel_init(), entity_HiddenPanel_set_ispy_notification(), ispy_notification_update(), and update_entities().

gEntityHideMode

s32 gEntityHideMode

Definition at line 37 of file entity.c.

Referenced by clear_entity_data(), and render_entities().

D_801512BC

s32 D_801512BC

Definition at line 39 of file entity.c.

Referenced by update_entities().

D_80151304

s32 D_80151304

Definition at line 40 of file entity.c.

Referenced by clear_entity_data().

D_80151344

s32 D_80151344

Definition at line 41 of file entity.c.

Referenced by clear_entity_data().

entity_numEntities

s32 entity_numEntities

Definition at line 42 of file entity.c.

Referenced by clear_entity_data(), init_entity_data(), and update_entities().

gEntityHeapBase

s32 gEntityHeapBase

Definition at line 43 of file entity.c.

Referenced by clear_entity_data(), init_entity_data(), load_simple_entity_data(), load_split_entity_data(), and reload_world_entity_data().

gLastCreatedEntityIndex

s32 gLastCreatedEntityIndex

Definition at line 44 of file entity.c.

gEntityHeapBottom

s32 gEntityHeapBottom

Definition at line 46 of file entity.c.

Referenced by clear_entity_data(), init_entity_data(), load_split_entity_data(), and reload_world_entity_data().

entity_numShadows

s32 entity_numShadows

Definition at line 47 of file entity.c.

Referenced by clear_entity_data(), init_entity_data(), and update_shadows().

isAreaSpecificEntityDataLoaded

s32 isAreaSpecificEntityDataLoaded

Definition at line 48 of file entity.c.

Referenced by clear_entity_data(), and load_area_specific_entity_data().

entity_updateCounter

s32 entity_updateCounter

Definition at line 49 of file entity.c.

Referenced by clear_entity_data(), and update_entities().

gWorldEntityList

BSS EntityList gWorldEntityList

Definition at line 51 of file entity.c.

Referenced by get_entity_list().

gBattleEntityList

BSS EntityList gBattleEntityList

Definition at line 52 of file entity.c.

Referenced by get_entity_list().

gCurrentEntityListPtr

BSS EntityList* gCurrentEntityListPtr

Definition at line 53 of file entity.c.

Referenced by clear_entity_data(), create_entity(), delete_entity(), delete_entity_and_unload_data(), func_80111790(), get_entity_by_index(), and init_entity_data().

gWorldShadowList

BSS ShadowList gWorldShadowList

Definition at line 54 of file entity.c.

Referenced by get_shadow_list().

gBattleShadowList

BSS ShadowList gBattleShadowList

Definition at line 55 of file entity.c.

Referenced by get_shadow_list().

gCurrentShadowListPtr

BSS ShadowList* gCurrentShadowListPtr

Definition at line 56 of file entity.c.

Referenced by clear_entity_data(), create_shadow_from_data(), delete_shadow(), get_shadow_by_index(), and init_entity_data().

wEntityDataLoadedSize

BSS s32 wEntityDataLoadedSize

Definition at line 58 of file entity.c.

Referenced by clear_entity_data(), entity_free_static_data(), load_simple_entity_data(), and load_split_entity_data().

bEntityDataLoadedSize

BSS s32 bEntityDataLoadedSize

Definition at line 59 of file entity.c.

Referenced by clear_entity_data(), load_simple_entity_data(), and load_split_entity_data().

wEntityBlueprint

BSS EntityBlueprint* wEntityBlueprint[MAX_ENTITIES+2]

Definition at line 61 of file entity.c.

Referenced by clear_entity_data(), entity_free_static_data(), is_entity_data_loaded(), and reload_world_entity_data().

bEntityBlueprint

BSS EntityBlueprint* bEntityBlueprint[4]

Definition at line 62 of file entity.c.

Referenced by clear_entity_data(), init_entity_data(), and is_entity_data_loaded().

D_801516FC

BSS s32 D_801516FC

Definition at line 63 of file entity.c.

Referenced by clear_entity_data().

BattleEntityHeapBottom

BSS u8 BattleEntityHeapBottom

extern

Referenced by clear_entity_data(), and init_entity_data().