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

21
scenes/editor_scene.c
View File

@ -2,6 +2,7 @@
#include "game_systems.h" #include "game_systems.h"
#include "constants.h" #include "constants.h"
#include "ent_impl.h" #include "ent_impl.h"
#include "mempool.h"
#include "raylib.h" #include "raylib.h"
#include "raymath.h" #include "raymath.h"
#include <stdio.h> #include <stdio.h>
@ -78,8 +79,8 @@ static void level_scene_render_func(Scene_t* scene)
char buffer[64] = {0}; char buffer[64] = {0};
sc_map_foreach_value(&scene->ent_manager.entities, p_ent) sc_map_foreach_value(&scene->ent_manager.entities, p_ent)
{ {
CTransform_t* p_ct = get_component(&scene->ent_manager, p_ent, CTRANSFORM_COMP_T); CTransform_t* p_ct = get_component(p_ent, CTRANSFORM_COMP_T);
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);
Color colour; Color colour;
switch(p_ent->m_tag) switch(p_ent->m_tag)
{ {
@ -93,8 +94,8 @@ static void level_scene_render_func(Scene_t* scene)
colour = BLACK; colour = BLACK;
} }
DrawRectangle(p_ct->position.x, p_ct->position.y, p_bbox->size.x, p_bbox->size.y, colour); 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); CHurtbox_t* p_hurtbox = get_component(p_ent, CHURTBOX_T);
CHitBoxes_t* p_hitbox = get_component(&scene->ent_manager, p_ent, CHITBOXES_T); CHitBoxes_t* p_hitbox = get_component(p_ent, CHITBOXES_T);
if (p_hitbox != NULL) if (p_hitbox != NULL)
{ {
for (uint8_t i = 0;i < p_hitbox->n_boxes; ++i) 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); 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) if (p_cspr != NULL)
{ {
const SpriteRenderInfo_t spr = p_cspr->sprites[p_cspr->current_idx]; 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; 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) 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); CTransform_t* p_ct = get_component(p_ent, CTRANSFORM_COMP_T);
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);
CPlayerState_t* p_pstate = get_component(&scene->ent_manager, p_ent, CPLAYERSTATE_T); CPlayerState_t* p_pstate = get_component(p_ent, CPLAYERSTATE_T);
CMovementState_t* p_mstate = get_component(&scene->ent_manager, p_ent, CMOVEMENTSTATE_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); sprintf(buffer, "Pos: %.3f\n %.3f", p_ct->position.x, p_ct->position.y);
DrawText(buffer, gui_x, 15, 12, BLACK); DrawText(buffer, gui_x, 15, 12, BLACK);
sprintf(buffer, "Vel: %.3f\n %.3f", p_ct->velocity.x, p_ct->velocity.y); 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); LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
Entity_t* p_crate = create_crate(&scene->ent_manager, &scene->engine->assets, metal); 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.x = (tile_idx % data->tilemap.width) * TILE_SIZE;
p_ctransform->position.y = (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; unsigned long m_id;
EntityTag_t m_tag; EntityTag_t m_tag;
bool m_alive; bool m_alive;
unsigned long components[N_COMPONENTS]; unsigned long components[N_COMPONENTS];
EntityManager_t* manager;
}; };
struct EntityManager { 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); void remove_entity(EntityManager_t* p_manager, unsigned long id);
Entity_t *get_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* add_component(Entity_t *entity, ComponentEnum_t comp_type);
void* get_component(EntityManager_t* p_manager, Entity_t *entity, ComponentEnum_t comp_type); void* get_component(Entity_t *entity, ComponentEnum_t comp_type);
void remove_component(EntityManager_t* p_manager, Entity_t* entity, ComponentEnum_t comp_type); void remove_component(Entity_t* entity, ComponentEnum_t comp_type);
#endif // __ENTITY_H #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); sc_queue_add_last(&p_manager->to_add, e_idx);
} }
p_ent->manager = p_manager;
return p_ent; 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 // Components are not expected to be removed
// So, no need to extra steps to deal with iterator invalidation // 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_type_idx = (unsigned long)comp_type;
unsigned long comp_idx = 0; unsigned long comp_idx = 0;
@ -116,23 +117,23 @@ void* add_component(EntityManager_t* p_manager, Entity_t* p_entity, ComponentEnu
if (p_comp) if (p_comp)
{ {
p_entity->components[comp_type] = comp_idx; 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; 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; 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); void * p_comp = sc_map_get_64v(&p_entity->manager->component_map[comp_type_idx], p_entity->m_id);
if (!sc_map_found(&p_manager->component_map[comp_type_idx])) return NULL; if (!sc_map_found(&p_entity->manager->component_map[comp_type_idx])) return NULL;
return p_comp; 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; unsigned long comp_type_idx = (unsigned long)comp_type;
if (p_entity->components[comp_type] == MAX_COMP_POOL_SIZE) return; 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]); 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; if (ent->idx == ent_idx) continue;
Entity_t * p_ent = get_entity(p_manager, ent_idx); Entity_t * p_ent = get_entity(p_manager, ent_idx);
CTransform_t *p_ctransform = get_component(p_manager, p_ent, CTRANSFORM_COMP_T); CTransform_t *p_ctransform = get_component(p_ent, CTRANSFORM_COMP_T);
CBBox_t *p_bbox = get_component(p_manager, p_ent, CBBOX_COMP_T); CBBox_t *p_bbox = get_component(p_ent, CBBOX_COMP_T);
if (p_bbox == NULL || p_ctransform == NULL) continue; if (p_bbox == NULL || p_ctransform == NULL) continue;
//if (p_bbox->solid && !p_bbox->fragile) //if (p_bbox->solid && !p_bbox->fragile)
if (p_bbox->solid) 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) 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); 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); CTransform_t* p_ctransform = get_component(p_player, CTRANSFORM_COMP_T);
CBBox_t* p_bbox = get_component(&scene->ent_manager, p_player, CBBOX_COMP_T); CBBox_t* p_bbox = get_component(p_player, CBBOX_COMP_T);
CJump_t* p_cjump = get_component(&scene->ent_manager, p_player, CJUMP_COMP_T); CJump_t* p_cjump = get_component(p_player, CJUMP_COMP_T);
CMovementState_t* p_mstate = get_component(&scene->ent_manager, p_player, CMOVEMENTSTATE_T); CMovementState_t* p_mstate = get_component(p_player, CMOVEMENTSTATE_T);
// Ladder handling // Ladder handling
if (!p_pstate->ladder_state) if (!p_pstate->ladder_state)
@ -478,10 +478,10 @@ void player_bbox_update_system(Scene_t* scene)
Entity_t* p_player; Entity_t* p_player;
sc_map_foreach_value(&scene->ent_manager.entities_map[PLAYER_ENT_TAG], 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); CTransform_t* p_ctransform = get_component(p_player, CTRANSFORM_COMP_T);
CBBox_t* p_bbox = get_component(&scene->ent_manager, p_player, CBBOX_COMP_T); CBBox_t* p_bbox = get_component(p_player, CBBOX_COMP_T);
CPlayerState_t* p_pstate = get_component(&scene->ent_manager, p_player, CPLAYERSTATE_T); CPlayerState_t* p_pstate = get_component(p_player, CPLAYERSTATE_T);
CMovementState_t* p_mstate = get_component(&scene->ent_manager, p_player, CMOVEMENTSTATE_T); CMovementState_t* p_mstate = get_component(p_player, CMOVEMENTSTATE_T);
Vector2 new_bbox; Vector2 new_bbox;
Vector2 offset; Vector2 offset;
@ -527,7 +527,7 @@ void player_bbox_update_system(Scene_t* scene)
p_ctransform->position = Vector2Add(p_ctransform->position, offset); 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[0].height = p_bbox->size.y + 2;
//p_hitbox->boxes[1].y = p_bbox->size.y / 4; //p_hitbox->boxes[1].y = p_bbox->size.y / 4;
p_hitbox->boxes[1].height = p_bbox->size.y - 1; 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) 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); 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 // Get the occupied tiles
// For each tile, loop through the entities, check collision and move // For each tile, loop through the entities, check collision and move
// exclude self // 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); 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_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 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; 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( check_collision_and_move(
&scene->ent_manager, &tilemap, ent_idx, &scene->ent_manager, &tilemap, ent_idx,
p_ctransform, p_bbox->size, p_other_ct->position, 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) 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); 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 // Friction
@ -718,7 +718,7 @@ void friction_coefficient_update_system(Scene_t* scene)
p_ct->fric_coeff = (Vector2){-3.3, -1}; 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)) if (p_pstate != NULL && (p_pstate->is_crouch & 1))
{ {
p_ct->fric_coeff.x -= 4; 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) 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); 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);
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_mstate->ground_state & 1)) 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) 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); 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) if (p_pstate->ladder_state)
{ {
p_ctransform->accel = (Vector2){0,0}; p_ctransform->accel = (Vector2){0,0};
@ -839,9 +839,9 @@ void player_ground_air_transition_system(Scene_t* scene)
Entity_t* p_player; Entity_t* p_player;
sc_map_foreach_value(&scene->ent_manager.entities_map[PLAYER_ENT_TAG], 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); CJump_t* p_cjump = get_component(p_player, CJUMP_COMP_T);
CMovementState_t* p_mstate = get_component(&scene->ent_manager, p_player, CMOVEMENTSTATE_T); CMovementState_t* p_mstate = get_component(p_player, CMOVEMENTSTATE_T);
CPlayerState_t* p_pstate = get_component(&scene->ent_manager, p_player, CPLAYERSTATE_T); CPlayerState_t* p_pstate = get_component(p_player, CPLAYERSTATE_T);
// Handle Ground<->Air Transition // Handle Ground<->Air Transition
bool in_water = (p_mstate->water_state & 1); 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) 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); 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);
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_ctransform == NULL || p_bbox == NULL) continue; if (p_ctransform == NULL || p_bbox == NULL) continue;
bool on_ground = check_on_ground( 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) 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); 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; 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; if (p_bbox == NULL) continue;
// Update tilemap position // 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) 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); 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) for (uint8_t i = 0; i < p_hitbox->n_boxes; ++i)
{ {
Vector2 hitbox_pos = { 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_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 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; 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 hurtbox_pos = Vector2Add(p_other_ct->position, p_other_hurtbox->offset);
Vector2 overlap; Vector2 overlap;
@ -1021,8 +1021,8 @@ void hitbox_update_system(Scene_t* scene)
if (p_other_ent->m_tag == CRATES_ENT_TAG) if (p_other_ent->m_tag == CRATES_ENT_TAG)
{ {
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);
CPlayerState_t* p_pstate = get_component(&scene->ent_manager, p_ent, CPLAYERSTATE_T); CPlayerState_t* p_pstate = get_component(p_ent, CPLAYERSTATE_T);
if ( if (
// TODO: Check Material of the crates // TODO: Check Material of the crates
p_ctransform->position.y + p_bbox->size.y <= p_other_ct->position.y 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) if (p_pstate->jump_pressed)
{ {
p_ctransform->velocity.y = -600; 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->short_hop = false;
p_cjump->jumped = true; p_cjump->jumped = true;
} }
} }
CTileCoord_t* p_tilecoord = get_component( 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) 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; const int height = lvl_scene->data.game_rec.height;
sc_map_foreach_value(&scene->ent_manager.entities_map[PLAYER_ENT_TAG], 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); 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.offset = (Vector2){ width/2.0f, height/2.0f };
lvl_scene->data.cam.target = p_ctransform->position; 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* create_crate(EntityManager_t* ent_manager, Assets_t* assets, bool metal)
{ {
Entity_t* p_crate = add_entity(ent_manager, CRATES_ENT_TAG); 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); set_bbox(p_bbox, TILE_SIZE, TILE_SIZE);
p_bbox->solid = true; p_bbox->solid = true;
p_bbox->fragile = !metal; p_bbox->fragile = !metal;
add_component(ent_manager, p_crate, CTRANSFORM_COMP_T); add_component(p_crate, CTRANSFORM_COMP_T);
add_component(ent_manager, p_crate, CMOVEMENTSTATE_T); add_component(p_crate, CMOVEMENTSTATE_T);
add_component(ent_manager, p_crate, CTILECOORD_COMP_T); add_component(p_crate, CTILECOORD_COMP_T);
CHurtbox_t* p_hurtbox = add_component(ent_manager, p_crate, CHURTBOX_T); CHurtbox_t* p_hurtbox = add_component(p_crate, CHURTBOX_T);
p_hurtbox->size = p_bbox->size; p_hurtbox->size = p_bbox->size;
p_hurtbox->fragile = !metal; p_hurtbox->fragile = !metal;
return p_crate; 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* create_player(EntityManager_t* ent_manager, Assets_t* assets)
{ {
Entity_t* p_ent = add_entity(ent_manager, PLAYER_ENT_TAG); 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); 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->jump_speed = 680;
p_cjump->jumps = 1; p_cjump->jumps = 1;
p_cjump->max_jumps = 1; p_cjump->max_jumps = 1;
p_cjump->jump_ready = true; p_cjump->jump_ready = true;
add_component(ent_manager, p_ent, CPLAYERSTATE_T); add_component(p_ent, CPLAYERSTATE_T);
add_component(ent_manager, p_ent, CTILECOORD_COMP_T); add_component(p_ent, CTILECOORD_COMP_T);
add_component(ent_manager, p_ent, CMOVEMENTSTATE_T); add_component(p_ent, CMOVEMENTSTATE_T);
CHitBoxes_t* p_hitbox = add_component(ent_manager, p_ent, CHITBOXES_T); CHitBoxes_t* p_hitbox = add_component(p_ent, CHITBOXES_T);
p_hitbox->n_boxes = 2; p_hitbox->n_boxes = 2;
p_hitbox->boxes[0] = (Rectangle) { p_hitbox->boxes[0] = (Rectangle) {
.x = 0, .x = 0,
@ -47,7 +47,7 @@ Entity_t* create_player(EntityManager_t* ent_manager, Assets_t* assets)
.width = p_bbox->size.x + 2, .width = p_bbox->size.x + 2,
.height = p_bbox->size.y - 1, .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->sprites = player_sprite_map;
p_cspr->transition_func = &player_sprite_transition_func; p_cspr->transition_func = &player_sprite_transition_func;