sadpmpk
/
HATPC
1
0
Fork 0
Code Issues 11 Pull Requests Projects 4 Releases Wiki Activity

Add manager field to an entity 

Since an entity is essentially tied to a manager, put it as a field in
Entity. This means no need to pass entity manager when getting a
component, which is more intuitive.
scene_man
En Yi 2023-05-23 21:00:23 +08:00
parent 4478a512a3
commit bc7f9ef777
7 changed files with 75 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
entManager_test.c
View File

@ -11,10 +11,10 @@ int main(void)
puts("Creating two entities");
Entity_t *p_ent = add_entity(&manager, PLAYER_ENT_TAG);
CBBox_t * p_bbox = (CBBox_t *)add_component(&manager, p_ent, CBBOX_COMP_T);
CBBox_t * p_bbox = (CBBox_t *)add_component(p_ent, CBBOX_COMP_T);
p_bbox->size.x = 15;
p_ent = add_entity(&manager, ENEMY_ENT_TAG);
p_bbox = (CBBox_t *)add_component(&manager, p_ent, CBBOX_COMP_T);
p_bbox = (CBBox_t *)add_component(p_ent, CBBOX_COMP_T);
p_bbox->size.y = 40;
update_entity_manager(&manager);
@ -22,7 +22,7 @@ int main(void)
unsigned long idx = 0;
sc_map_foreach(&manager.entities, idx, p_ent)
{
p_bbox = (CBBox_t *)get_component(&manager, p_ent, CBBOX_COMP_T);
p_bbox = (CBBox_t *)get_component(p_ent, CBBOX_COMP_T);
printf("BBOX: %f,%f\n", p_bbox->size.x, p_bbox->size.y);
remove_entity(&manager, idx);
}
@ -32,7 +32,7 @@ int main(void)
puts("Print again, should show nothing");
sc_map_foreach(&manager.entities, idx, p_ent)
{
p_bbox = (CBBox_t *)get_component(&manager, p_ent, CBBOX_COMP_T);
p_bbox = (CBBox_t *)get_component(p_ent, CBBOX_COMP_T);
printf("BBOX: %f,%f\n", p_bbox->size.x, p_bbox->size.y);
remove_entity(&manager, idx);
}

21
scenes/editor_scene.c
View File

@ -2,6 +2,7 @@
#include "game_systems.h"
#include "constants.h"
#include "ent_impl.h"
#include "mempool.h"
#include "raylib.h"
#include "raymath.h"
#include <stdio.h>
@ -78,8 +79,8 @@ static void level_scene_render_func(Scene_t* scene)
char buffer[64] = {0};
sc_map_foreach_value(&scene->ent_manager.entities, p_ent)
{
CTransform_t* p_ct = get_component(&scene->ent_manager, p_ent, CTRANSFORM_COMP_T);
CBBox_t* p_bbox = get_component(&scene->ent_manager, p_ent, CBBOX_COMP_T);
CTransform_t* p_ct = get_component(p_ent, CTRANSFORM_COMP_T);
CBBox_t* p_bbox = get_component(p_ent, CBBOX_COMP_T);
Color colour;
switch(p_ent->m_tag)
{
@ -93,8 +94,8 @@ static void level_scene_render_func(Scene_t* scene)
colour = BLACK;
}
DrawRectangle(p_ct->position.x, p_ct->position.y, p_bbox->size.x, p_bbox->size.y, colour);
CHurtbox_t* p_hurtbox = get_component(&scene->ent_manager, p_ent, CHURTBOX_T);
CHitBoxes_t* p_hitbox = get_component(&scene->ent_manager, p_ent, CHITBOXES_T);
CHurtbox_t* p_hurtbox = get_component(p_ent, CHURTBOX_T);
CHitBoxes_t* p_hitbox = get_component(p_ent, CHITBOXES_T);
if (p_hitbox != NULL)
{
for (uint8_t i = 0;i < p_hitbox->n_boxes; ++i)
@ -118,7 +119,7 @@ static void level_scene_render_func(Scene_t* scene)
};
DrawRectangleLinesEx(rec, 1.5, PURPLE);
}
CSprite_t* p_cspr = get_component(&scene->ent_manager, p_ent, CSPRITE_T);
CSprite_t* p_cspr = get_component(p_ent, CSPRITE_T);
if (p_cspr != NULL)
{
const SpriteRenderInfo_t spr = p_cspr->sprites[p_cspr->current_idx];
@ -177,10 +178,10 @@ static void level_scene_render_func(Scene_t* scene)
const int gui_x = data->game_rec.x + data->game_rec.width + 10;
sc_map_foreach_value(&scene->ent_manager.entities_map[PLAYER_ENT_TAG], p_ent)
{
CTransform_t* p_ct = get_component(&scene->ent_manager, p_ent, CTRANSFORM_COMP_T);
CJump_t* p_cjump = get_component(&scene->ent_manager, p_ent, CJUMP_COMP_T);
CPlayerState_t* p_pstate = get_component(&scene->ent_manager, p_ent, CPLAYERSTATE_T);
CMovementState_t* p_mstate = get_component(&scene->ent_manager, p_ent, CMOVEMENTSTATE_T);
CTransform_t* p_ct = get_component(p_ent, CTRANSFORM_COMP_T);
CJump_t* p_cjump = get_component(p_ent, CJUMP_COMP_T);
CPlayerState_t* p_pstate = get_component(p_ent, CPLAYERSTATE_T);
CMovementState_t* p_mstate = get_component(p_ent, CMOVEMENTSTATE_T);
sprintf(buffer, "Pos: %.3f\n %.3f", p_ct->position.x, p_ct->position.y);
DrawText(buffer, gui_x, 15, 12, BLACK);
sprintf(buffer, "Vel: %.3f\n %.3f", p_ct->velocity.x, p_ct->velocity.y);
@ -214,7 +215,7 @@ static void spawn_crate(Scene_t* scene, unsigned int tile_idx, bool metal)
LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
Entity_t* p_crate = create_crate(&scene->ent_manager, &scene->engine->assets, metal);
CTransform_t* p_ctransform = get_component(&scene->ent_manager, p_crate, CTRANSFORM_COMP_T);
CTransform_t* p_ctransform = get_component(p_crate, CTRANSFORM_COMP_T);
p_ctransform->position.x = (tile_idx % data->tilemap.width) * TILE_SIZE;
p_ctransform->position.y = (tile_idx / data->tilemap.width) * TILE_SIZE;
}

9
scenes/engine/EC/EC.h
View File

@ -153,7 +153,8 @@ struct Entity {
unsigned long m_id;
EntityTag_t m_tag;
bool m_alive;
unsigned long components[N_COMPONENTS];
unsigned long components[N_COMPONENTS];
EntityManager_t* manager;
};
struct EntityManager {
@ -174,8 +175,8 @@ Entity_t* add_entity(EntityManager_t* p_manager, EntityTag_t tag);
void remove_entity(EntityManager_t* p_manager, unsigned long id);
Entity_t *get_entity(EntityManager_t* p_manager, unsigned long id);
void* add_component(EntityManager_t* p_manager, Entity_t *entity, ComponentEnum_t comp_type);
void* get_component(EntityManager_t* p_manager, Entity_t *entity, ComponentEnum_t comp_type);
void remove_component(EntityManager_t* p_manager, Entity_t* entity, ComponentEnum_t comp_type);
void* add_component(Entity_t *entity, ComponentEnum_t comp_type);
void* get_component(Entity_t *entity, ComponentEnum_t comp_type);
void remove_component(Entity_t* entity, ComponentEnum_t comp_type);
#endif // __ENTITY_H

15
scenes/engine/EC/entManager.c
View File

@ -83,6 +83,7 @@ Entity_t *add_entity(EntityManager_t* p_manager, EntityTag_t tag)
{
sc_queue_add_last(&p_manager->to_add, e_idx);
}
p_ent->manager = p_manager;
return p_ent;
}
@ -108,7 +109,7 @@ Entity_t* get_entity(EntityManager_t* p_manager, unsigned long id)
// Components are not expected to be removed
// So, no need to extra steps to deal with iterator invalidation
void* add_component(EntityManager_t* p_manager, Entity_t* p_entity, ComponentEnum_t comp_type)
void* add_component(Entity_t* p_entity, ComponentEnum_t comp_type)
{
unsigned long comp_type_idx = (unsigned long)comp_type;
unsigned long comp_idx = 0;
@ -116,23 +117,23 @@ void* add_component(EntityManager_t* p_manager, Entity_t* p_entity, ComponentEnu
if (p_comp)
{
p_entity->components[comp_type] = comp_idx;
sc_map_put_64v(&p_manager->component_map[comp_type_idx], p_entity->m_id, p_comp);
sc_map_put_64v(&p_entity->manager->component_map[comp_type_idx], p_entity->m_id, p_comp);
}
return p_comp;
}
void* get_component(EntityManager_t *p_manager, Entity_t *p_entity, ComponentEnum_t comp_type)
void* get_component(Entity_t *p_entity, ComponentEnum_t comp_type)
{
unsigned long comp_type_idx = (unsigned long)comp_type;
void * p_comp = sc_map_get_64v(&p_manager->component_map[comp_type_idx], p_entity->m_id);
if (!sc_map_found(&p_manager->component_map[comp_type_idx])) return NULL;
void * p_comp = sc_map_get_64v(&p_entity->manager->component_map[comp_type_idx], p_entity->m_id);
if (!sc_map_found(&p_entity->manager->component_map[comp_type_idx])) return NULL;
return p_comp;
}
void remove_component(EntityManager_t *p_manager, Entity_t *p_entity, ComponentEnum_t comp_type)
void remove_component(Entity_t *p_entity, ComponentEnum_t comp_type)
{
unsigned long comp_type_idx = (unsigned long)comp_type;
if (p_entity->components[comp_type] == MAX_COMP_POOL_SIZE) return;
sc_map_del_64v(&p_manager->component_map[comp_type_idx], p_entity->m_id);
sc_map_del_64v(&p_entity->manager->component_map[comp_type_idx], p_entity->m_id);
free_component_to_mempool(comp_type, p_entity->components[comp_type]);
}

68
scenes/game_systems.c
View File

@ -67,8 +67,8 @@ static bool check_collision(const CollideEntity_t* ent, TileGrid_t* grid, Entity
{
if (ent->idx == ent_idx) continue;
Entity_t * p_ent = get_entity(p_manager, ent_idx);
CTransform_t *p_ctransform = get_component(p_manager, p_ent, CTRANSFORM_COMP_T);
CBBox_t *p_bbox = get_component(p_manager, p_ent, CBBOX_COMP_T);
CTransform_t *p_ctransform = get_component(p_ent, CTRANSFORM_COMP_T);
CBBox_t *p_bbox = get_component(p_ent, CBBOX_COMP_T);
if (p_bbox == NULL || p_ctransform == NULL) continue;
//if (p_bbox->solid && !p_bbox->fragile)
if (p_bbox->solid)
@ -308,10 +308,10 @@ void player_movement_input_system(Scene_t* scene)
sc_map_foreach(&scene->ent_manager.component_map[CPLAYERSTATE_T], ent_idx, p_pstate)
{
Entity_t* p_player = get_entity(&scene->ent_manager, ent_idx);
CTransform_t* p_ctransform = get_component(&scene->ent_manager, p_player, CTRANSFORM_COMP_T);
CBBox_t* p_bbox = get_component(&scene->ent_manager, p_player, CBBOX_COMP_T);
CJump_t* p_cjump = get_component(&scene->ent_manager, p_player, CJUMP_COMP_T);
CMovementState_t* p_mstate = get_component(&scene->ent_manager, p_player, CMOVEMENTSTATE_T);
CTransform_t* p_ctransform = get_component(p_player, CTRANSFORM_COMP_T);
CBBox_t* p_bbox = get_component(p_player, CBBOX_COMP_T);
CJump_t* p_cjump = get_component(p_player, CJUMP_COMP_T);
CMovementState_t* p_mstate = get_component(p_player, CMOVEMENTSTATE_T);
// Ladder handling
if (!p_pstate->ladder_state)
@ -478,10 +478,10 @@ void player_bbox_update_system(Scene_t* scene)
Entity_t* p_player;
sc_map_foreach_value(&scene->ent_manager.entities_map[PLAYER_ENT_TAG], p_player)
{
CTransform_t* p_ctransform = get_component(&scene->ent_manager, p_player, CTRANSFORM_COMP_T);
CBBox_t* p_bbox = get_component(&scene->ent_manager, p_player, CBBOX_COMP_T);
CPlayerState_t* p_pstate = get_component(&scene->ent_manager, p_player, CPLAYERSTATE_T);
CMovementState_t* p_mstate = get_component(&scene->ent_manager, p_player, CMOVEMENTSTATE_T);
CTransform_t* p_ctransform = get_component(p_player, CTRANSFORM_COMP_T);
CBBox_t* p_bbox = get_component(p_player, CBBOX_COMP_T);
CPlayerState_t* p_pstate = get_component(p_player, CPLAYERSTATE_T);
CMovementState_t* p_mstate = get_component(p_player, CMOVEMENTSTATE_T);
Vector2 new_bbox;
Vector2 offset;
@ -527,7 +527,7 @@ void player_bbox_update_system(Scene_t* scene)
p_ctransform->position = Vector2Add(p_ctransform->position, offset);
}
CHitBoxes_t* p_hitbox = get_component(&scene->ent_manager, p_player, CHITBOXES_T);
CHitBoxes_t* p_hitbox = get_component(p_player, CHITBOXES_T);
p_hitbox->boxes[0].height = p_bbox->size.y + 2;
//p_hitbox->boxes[1].y = p_bbox->size.y / 4;
p_hitbox->boxes[1].height = p_bbox->size.y - 1;
@ -548,7 +548,7 @@ void tile_collision_system(Scene_t* scene)
sc_map_foreach(&scene->ent_manager.component_map[CBBOX_COMP_T], ent_idx, p_bbox)
{
Entity_t* p_ent = get_entity(&scene->ent_manager, ent_idx);
CTransform_t* p_ctransform = get_component(&scene->ent_manager, p_ent, CTRANSFORM_COMP_T);
CTransform_t* p_ctransform = get_component(p_ent, CTRANSFORM_COMP_T);
// Get the occupied tiles
// For each tile, loop through the entities, check collision and move
// exclude self
@ -588,10 +588,10 @@ void tile_collision_system(Scene_t* scene)
Entity_t *p_other_ent = get_entity(&scene->ent_manager, other_ent_idx);
if (!p_other_ent->m_alive) continue; // To only allow one way collision check
if (p_other_ent->m_tag < p_ent->m_tag) continue; // To only allow one way collision check
CBBox_t *p_other_bbox = get_component(&scene->ent_manager, p_other_ent, CBBOX_COMP_T);
CBBox_t *p_other_bbox = get_component(p_other_ent, CBBOX_COMP_T);
if (p_other_bbox == NULL) continue;
CTransform_t *p_other_ct = get_component(&scene->ent_manager, p_other_ent, CTRANSFORM_COMP_T);
CTransform_t *p_other_ct = get_component(p_other_ent, CTRANSFORM_COMP_T);
check_collision_and_move(
&scene->ent_manager, &tilemap, ent_idx,
p_ctransform, p_bbox->size, p_other_ct->position,
@ -699,7 +699,7 @@ void friction_coefficient_update_system(Scene_t* scene)
sc_map_foreach(&scene->ent_manager.component_map[CTRANSFORM_COMP_T], ent_idx, p_ct)
{
Entity_t* p_ent = get_entity(&scene->ent_manager, ent_idx);
CMovementState_t* p_mstate = get_component(&scene->ent_manager, p_ent, CMOVEMENTSTATE_T);
CMovementState_t* p_mstate = get_component(p_ent, CMOVEMENTSTATE_T);
// Friction
@ -718,7 +718,7 @@ void friction_coefficient_update_system(Scene_t* scene)
p_ct->fric_coeff = (Vector2){-3.3, -1};
}
CPlayerState_t* p_pstate = get_component(&scene->ent_manager, p_ent, CPLAYERSTATE_T);
CPlayerState_t* p_pstate = get_component(p_ent, CPLAYERSTATE_T);
if (p_pstate != NULL && (p_pstate->is_crouch & 1))
{
p_ct->fric_coeff.x -= 4;
@ -734,8 +734,8 @@ void global_external_forces_system(Scene_t* scene)
sc_map_foreach(&scene->ent_manager.component_map[CMOVEMENTSTATE_T], ent_idx, p_mstate)
{
Entity_t* p_ent = get_entity(&scene->ent_manager, ent_idx);
CTransform_t* p_ctransform = get_component(&scene->ent_manager, p_ent, CTRANSFORM_COMP_T);
CBBox_t* p_bbox = get_component(&scene->ent_manager, p_ent, CBBOX_COMP_T);
CTransform_t* p_ctransform = get_component(p_ent, CTRANSFORM_COMP_T);
CBBox_t* p_bbox = get_component(p_ent, CBBOX_COMP_T);
if (!(p_mstate->ground_state & 1))
{
@ -791,7 +791,7 @@ void global_external_forces_system(Scene_t* scene)
sc_map_foreach(&scene->ent_manager.component_map[CPLAYERSTATE_T], ent_idx, p_pstate)
{
Entity_t* p_ent = get_entity(&scene->ent_manager, ent_idx);
CTransform_t* p_ctransform = get_component(&scene->ent_manager, p_ent, CTRANSFORM_COMP_T);
CTransform_t* p_ctransform = get_component(p_ent, CTRANSFORM_COMP_T);
if (p_pstate->ladder_state)
{
p_ctransform->accel = (Vector2){0,0};
@ -839,9 +839,9 @@ void player_ground_air_transition_system(Scene_t* scene)
Entity_t* p_player;
sc_map_foreach_value(&scene->ent_manager.entities_map[PLAYER_ENT_TAG], p_player)
{
CJump_t* p_cjump = get_component(&scene->ent_manager, p_player, CJUMP_COMP_T);
CMovementState_t* p_mstate = get_component(&scene->ent_manager, p_player, CMOVEMENTSTATE_T);
CPlayerState_t* p_pstate = get_component(&scene->ent_manager, p_player, CPLAYERSTATE_T);
CJump_t* p_cjump = get_component(p_player, CJUMP_COMP_T);
CMovementState_t* p_mstate = get_component(p_player, CMOVEMENTSTATE_T);
CPlayerState_t* p_pstate = get_component(p_player, CPLAYERSTATE_T);
// Handle Ground<->Air Transition
bool in_water = (p_mstate->water_state & 1);
@ -875,8 +875,8 @@ void state_transition_update_system(Scene_t* scene)
sc_map_foreach(&scene->ent_manager.component_map[CMOVEMENTSTATE_T], ent_idx, p_mstate)
{
Entity_t* p_ent = get_entity(&scene->ent_manager, ent_idx);
CTransform_t* p_ctransform = get_component(&scene->ent_manager, p_ent, CTRANSFORM_COMP_T);
CBBox_t* p_bbox = get_component(&scene->ent_manager, p_ent, CBBOX_COMP_T);
CTransform_t* p_ctransform = get_component(p_ent, CTRANSFORM_COMP_T);
CBBox_t* p_bbox = get_component(p_ent, CBBOX_COMP_T);
if (p_ctransform == NULL || p_bbox == NULL) continue;
bool on_ground = check_on_ground(
@ -928,9 +928,9 @@ void update_tilemap_system(Scene_t* scene)
sc_map_foreach(&scene->ent_manager.component_map[CTILECOORD_COMP_T], ent_idx, p_tilecoord)
{
Entity_t* p_ent = get_entity(&scene->ent_manager, ent_idx);
CTransform_t* p_ctransform = get_component(&scene->ent_manager, p_ent, CTRANSFORM_COMP_T);
CTransform_t* p_ctransform = get_component(p_ent, CTRANSFORM_COMP_T);
if (p_ctransform == NULL) continue;
CBBox_t* p_bbox = get_component(&scene->ent_manager, p_ent, CBBOX_COMP_T);
CBBox_t* p_bbox = get_component(p_ent, CBBOX_COMP_T);
if (p_bbox == NULL) continue;
// Update tilemap position
@ -975,7 +975,7 @@ void hitbox_update_system(Scene_t* scene)
sc_map_foreach(&scene->ent_manager.component_map[CHITBOXES_T], ent_idx, p_hitbox)
{
Entity_t *p_ent = get_entity(&scene->ent_manager, ent_idx);
CTransform_t* p_ctransform = get_component(&scene->ent_manager, p_ent, CTRANSFORM_COMP_T);
CTransform_t* p_ctransform = get_component(p_ent, CTRANSFORM_COMP_T);
for (uint8_t i = 0; i < p_hitbox->n_boxes; ++i)
{
Vector2 hitbox_pos = {
@ -1004,9 +1004,9 @@ void hitbox_update_system(Scene_t* scene)
if (!p_other_ent->m_alive) continue; // To only allow one way collision check
if (p_other_ent->m_tag < p_ent->m_tag) continue; // To only allow one way collision check
CHurtbox_t* p_other_hurtbox = get_component(&scene->ent_manager, p_other_ent, CHURTBOX_T);
CHurtbox_t* p_other_hurtbox = get_component(p_other_ent, CHURTBOX_T);
if (p_other_hurtbox == NULL) continue;
CTransform_t* p_other_ct = get_component(&scene->ent_manager, p_other_ent, CTRANSFORM_COMP_T);
CTransform_t* p_other_ct = get_component(p_other_ent, CTRANSFORM_COMP_T);
Vector2 hurtbox_pos = Vector2Add(p_other_ct->position, p_other_hurtbox->offset);
Vector2 overlap;
@ -1021,8 +1021,8 @@ void hitbox_update_system(Scene_t* scene)
if (p_other_ent->m_tag == CRATES_ENT_TAG)
{
CBBox_t* p_bbox = get_component(&scene->ent_manager, p_ent, CBBOX_COMP_T);
CPlayerState_t* p_pstate = get_component(&scene->ent_manager, p_ent, CPLAYERSTATE_T);
CBBox_t* p_bbox = get_component(p_ent, CBBOX_COMP_T);
CPlayerState_t* p_pstate = get_component(p_ent, CPLAYERSTATE_T);
if (
// TODO: Check Material of the crates
p_ctransform->position.y + p_bbox->size.y <= p_other_ct->position.y
@ -1032,14 +1032,14 @@ void hitbox_update_system(Scene_t* scene)
if (p_pstate->jump_pressed)
{
p_ctransform->velocity.y = -600;
CJump_t * p_cjump = get_component(&scene->ent_manager, p_ent, CJUMP_COMP_T);
CJump_t * p_cjump = get_component(p_ent, CJUMP_COMP_T);
p_cjump->short_hop = false;
p_cjump->jumped = true;
}
}
CTileCoord_t* p_tilecoord = get_component(
&scene->ent_manager, p_other_ent, CTILECOORD_COMP_T
p_other_ent, CTILECOORD_COMP_T
);
for (size_t i = 0;i < p_tilecoord->n_tiles; ++i)
@ -1096,7 +1096,7 @@ void camera_update_system(Scene_t* scene)
const int height = lvl_scene->data.game_rec.height;
sc_map_foreach_value(&scene->ent_manager.entities_map[PLAYER_ENT_TAG], p_player)
{
CTransform_t* p_ctransform = get_component(&scene->ent_manager, p_player, CTRANSFORM_COMP_T);
CTransform_t* p_ctransform = get_component(p_player, CTRANSFORM_COMP_T);
lvl_scene->data.cam.offset = (Vector2){ width/2.0f, height/2.0f };
lvl_scene->data.cam.target = p_ctransform->position;
}

10
scenes/items_ent.c
View File

@ -4,16 +4,16 @@
Entity_t* create_crate(EntityManager_t* ent_manager, Assets_t* assets, bool metal)
{
Entity_t* p_crate = add_entity(ent_manager, CRATES_ENT_TAG);
CBBox_t* p_bbox = add_component(ent_manager, p_crate, CBBOX_COMP_T);
CBBox_t* p_bbox = add_component(p_crate, CBBOX_COMP_T);
set_bbox(p_bbox, TILE_SIZE, TILE_SIZE);
p_bbox->solid = true;
p_bbox->fragile = !metal;
add_component(ent_manager, p_crate, CTRANSFORM_COMP_T);
add_component(ent_manager, p_crate, CMOVEMENTSTATE_T);
add_component(ent_manager, p_crate, CTILECOORD_COMP_T);
CHurtbox_t* p_hurtbox = add_component(ent_manager, p_crate, CHURTBOX_T);
add_component(p_crate, CTRANSFORM_COMP_T);
add_component(p_crate, CMOVEMENTSTATE_T);
add_component(p_crate, CTILECOORD_COMP_T);
CHurtbox_t* p_hurtbox = add_component(p_crate, CHURTBOX_T);
p_hurtbox->size = p_bbox->size;
p_hurtbox->fragile = !metal;
return p_crate;

16
scenes/player_ent.c
View File

@ -20,20 +20,20 @@ static unsigned int player_sprite_transition_func(Entity_t* ent)
Entity_t* create_player(EntityManager_t* ent_manager, Assets_t* assets)
{
Entity_t* p_ent = add_entity(ent_manager, PLAYER_ENT_TAG);
CBBox_t* p_bbox = add_component(ent_manager, p_ent, CBBOX_COMP_T);
CBBox_t* p_bbox = add_component(p_ent, CBBOX_COMP_T);
set_bbox(p_bbox, PLAYER_WIDTH, PLAYER_HEIGHT);
add_component(ent_manager, p_ent, CTRANSFORM_COMP_T);
add_component(p_ent, CTRANSFORM_COMP_T);
CJump_t* p_cjump = add_component(ent_manager, p_ent, CJUMP_COMP_T);
CJump_t* p_cjump = add_component(p_ent, CJUMP_COMP_T);
p_cjump->jump_speed = 680;
p_cjump->jumps = 1;
p_cjump->max_jumps = 1;
p_cjump->jump_ready = true;
add_component(ent_manager, p_ent, CPLAYERSTATE_T);
add_component(ent_manager, p_ent, CTILECOORD_COMP_T);
add_component(ent_manager, p_ent, CMOVEMENTSTATE_T);
CHitBoxes_t* p_hitbox = add_component(ent_manager, p_ent, CHITBOXES_T);
add_component(p_ent, CPLAYERSTATE_T);
add_component(p_ent, CTILECOORD_COMP_T);
add_component(p_ent, CMOVEMENTSTATE_T);
CHitBoxes_t* p_hitbox = add_component(p_ent, CHITBOXES_T);
p_hitbox->n_boxes = 2;
p_hitbox->boxes[0] = (Rectangle) {
.x = 0,
@ -47,7 +47,7 @@ Entity_t* create_player(EntityManager_t* ent_manager, Assets_t* assets)
.width = p_bbox->size.x + 2,
.height = p_bbox->size.y - 1,
};
CSprite_t* p_cspr = add_component(ent_manager, p_ent, CSPRITE_T);
CSprite_t* p_cspr = add_component(p_ent, CSPRITE_T);
p_cspr->sprites = player_sprite_map;
p_cspr->transition_func = &player_sprite_transition_func;