1265 lines
69 KiB
C++
1265 lines
69 KiB
C++
#if defined(__clang__)
|
|
#pragma once
|
|
#include "feely_pona_unity.h"
|
|
#endif
|
|
|
|
struct FP_GlobalAnimations
|
|
{
|
|
Dqn_String8 terry_walk_idle = DQN_STRING8("terry_walk_idle");
|
|
Dqn_String8 terry_walk_up = DQN_STRING8("terry_walk_up");
|
|
Dqn_String8 terry_walk_down = DQN_STRING8("terry_walk_down");
|
|
Dqn_String8 terry_walk_left = DQN_STRING8("terry_walk_left");
|
|
Dqn_String8 terry_walk_right = DQN_STRING8("terry_walk_right");
|
|
Dqn_String8 terry_attack_up = DQN_STRING8("terry_attack_up");
|
|
Dqn_String8 terry_attack_side = DQN_STRING8("terry_attack_side");
|
|
Dqn_String8 terry_attack_down = DQN_STRING8("terry_attack_down");
|
|
Dqn_String8 terry_merchant = DQN_STRING8("terry_merchant");
|
|
Dqn_String8 smoochie_walk_up = DQN_STRING8("smoochie_walk_up");
|
|
Dqn_String8 smoochie_walk_down = DQN_STRING8("smoochie_walk_down");
|
|
Dqn_String8 smoochie_walk_left = DQN_STRING8("smoochie_walk_left");
|
|
Dqn_String8 smoochie_walk_right = DQN_STRING8("smoochie_walk_right");
|
|
Dqn_String8 smoochie_attack_down = DQN_STRING8("smoochie_attack");
|
|
Dqn_String8 smoochie_attack_side = DQN_STRING8("smoochie_attack_side");
|
|
Dqn_String8 smoochie_attack_heart = DQN_STRING8("smoochie_attack_heart");
|
|
Dqn_String8 smoochie_death = DQN_STRING8("smoochie_death");
|
|
}
|
|
g_anim_names;
|
|
|
|
TELY_AssetSpriteSheet FP_LoadSpriteSheetFromSpec(TELY_Platform *platform, TELY_Assets *assets, Dqn_Arena *arena, Dqn_String8 sheet_name)
|
|
{
|
|
TELY_AssetSpriteSheet result = {};
|
|
Dqn_ThreadScratch scratch = Dqn_Thread_GetScratch(arena);
|
|
result.sprite_size = Dqn_V2I_InitNx2(185, 170);
|
|
result.type = TELY_AssetSpriteSheetType_Rects;
|
|
|
|
// NOTE: Load the sprite meta file =========================================================
|
|
Dqn_String8 sprite_spec_path = Dqn_FsPath_ConvertF(scratch.arena, "%.*s/%.*s.txt", DQN_STRING_FMT(assets->textures_dir), DQN_STRING_FMT(sheet_name));
|
|
Dqn_String8 sprite_spec_buffer = platform->func_load_file(scratch.arena, sprite_spec_path);
|
|
Dqn_String8SplitAllocResult lines = Dqn_String8_SplitAlloc(scratch.allocator, sprite_spec_buffer, DQN_STRING8("\n"));
|
|
Dqn_usize sprite_rect_index = 0;
|
|
Dqn_usize sprite_anim_index = 0;
|
|
|
|
DQN_FOR_UINDEX(line_index, lines.size) {
|
|
Dqn_String8 line = lines.data[line_index];
|
|
Dqn_String8SplitAllocResult line_splits = Dqn_String8_SplitAlloc(scratch.allocator, line, DQN_STRING8(";"));
|
|
|
|
if (line_index == 0) {
|
|
DQN_ASSERTF(line_splits.size == 4, "Expected 4 splits for @file lines");
|
|
DQN_ASSERT(Dqn_String8_StartsWith(line_splits.data[0], DQN_STRING8("@file"), Dqn_String8EqCase_Sensitive));
|
|
|
|
// NOTE: Sprite sheet path
|
|
Dqn_String8 sprite_sheet_path = Dqn_FsPath_ConvertF(scratch.arena, "%.*s/%.*s", DQN_STRING_FMT(assets->textures_dir), DQN_STRING_FMT(line_splits.data[1]));
|
|
result.tex_handle = platform->func_load_texture(assets, sheet_name, sprite_sheet_path);
|
|
DQN_ASSERTF(Dqn_Fs_Exists(sprite_sheet_path), "Required file does not exist '%.*s'", DQN_STRING_FMT(sprite_sheet_path));
|
|
|
|
// NOTE: Total sprite frame count
|
|
Dqn_String8ToU64Result total_frame_count = Dqn_String8_ToU64(line_splits.data[2], 0);
|
|
DQN_ASSERT(total_frame_count.success);
|
|
result.rects = Dqn_Slice_Alloc<Dqn_Rect>(arena, total_frame_count.value, Dqn_ZeroMem_No);
|
|
|
|
// NOTE: Total animation count
|
|
Dqn_String8ToU64Result total_anim_count = Dqn_String8_ToU64(line_splits.data[3], 0);
|
|
DQN_ASSERT(total_anim_count.success);
|
|
result.anims = Dqn_Slice_Alloc<TELY_AssetSpriteAnimation>(arena, total_anim_count.value, Dqn_ZeroMem_No);
|
|
|
|
// TODO: Sprite size?
|
|
|
|
// TODO: Texture name?
|
|
continue;
|
|
}
|
|
|
|
if (Dqn_String8_StartsWith(line, DQN_STRING8("@anim"))) {
|
|
DQN_ASSERTF(line_splits.size == 4, "Expected 4 splits for @anim lines");
|
|
Dqn_String8 anim_name = line_splits.data[1];
|
|
Dqn_String8ToU64Result frames_per_second = Dqn_String8_ToU64(line_splits.data[2], 0);
|
|
Dqn_String8ToU64Result frame_count = Dqn_String8_ToU64(line_splits.data[3], 0);
|
|
|
|
DQN_ASSERT(anim_name.size);
|
|
DQN_ASSERT(frame_count.success);
|
|
DQN_ASSERT(frames_per_second.success);
|
|
|
|
Dqn_Allocator allocator = Dqn_Arena_Allocator(arena);
|
|
TELY_AssetSpriteAnimation *anim = result.anims.data + sprite_anim_index++;
|
|
anim->label = Dqn_String8_Copy(allocator, anim_name);
|
|
anim->index = DQN_CAST(uint16_t)sprite_rect_index;
|
|
anim->count = DQN_CAST(uint16_t)frame_count.value;
|
|
anim->seconds_per_frame = 1.f / frames_per_second.value;
|
|
} else {
|
|
DQN_ASSERTF(line_splits.size == 4, "Expected 4 splits for sprite frame lines");
|
|
Dqn_String8ToU64Result x = Dqn_String8_ToU64(line_splits.data[0], 0);
|
|
Dqn_String8ToU64Result y = Dqn_String8_ToU64(line_splits.data[1], 0);
|
|
Dqn_String8ToU64Result w = Dqn_String8_ToU64(line_splits.data[2], 0);
|
|
Dqn_String8ToU64Result h = Dqn_String8_ToU64(line_splits.data[3], 0);
|
|
|
|
DQN_ASSERT(x.success);
|
|
DQN_ASSERT(y.success);
|
|
DQN_ASSERT(w.success);
|
|
DQN_ASSERT(h.success);
|
|
|
|
result.rects.data[sprite_rect_index++] =
|
|
Dqn_Rect_InitNx4(DQN_CAST(Dqn_f32) x.value,
|
|
DQN_CAST(Dqn_f32) y.value,
|
|
DQN_CAST(Dqn_f32) w.value,
|
|
DQN_CAST(Dqn_f32) h.value);
|
|
}
|
|
}
|
|
|
|
DQN_ASSERT(result.rects.size == sprite_rect_index);
|
|
DQN_ASSERT(result.anims.size == sprite_anim_index);
|
|
return result;
|
|
}
|
|
|
|
extern "C" __declspec(dllexport)
|
|
void TELY_DLL_Reload(void *user_data)
|
|
{
|
|
TELY_Platform *platform = DQN_CAST(TELY_Platform *)user_data;
|
|
Dqn_Library_SetPointer(platform->core.dqn_lib);
|
|
}
|
|
|
|
extern "C" __declspec(dllexport)
|
|
void TELY_DLL_Init(void *user_data)
|
|
{
|
|
TELY_Platform *platform = DQN_CAST(TELY_Platform *)user_data;
|
|
TELY_DLL_Reload(user_data);
|
|
|
|
FP_UnitTests(platform);
|
|
|
|
// NOTE: TELY Game =============================================================================
|
|
TELY_Assets *assets = &platform->assets;
|
|
FP_Game *game = Dqn_Arena_New(&platform->arena, FP_Game, Dqn_ZeroMem_Yes);
|
|
game->chunk_pool = &platform->chunk_pool;
|
|
platform->user_data = game;
|
|
{
|
|
TELY_AssetSpriteSheet *sheet = &game->hero_sprite_sheet;
|
|
Dqn_ThreadScratch scratch = Dqn_Thread_GetScratch(nullptr);
|
|
Dqn_String8 sheet_path = Dqn_FsPath_ConvertF(scratch.arena, "%.*s/adventurer-v1.5-sheet.png", DQN_STRING_FMT(assets->textures_dir));
|
|
sheet->tex_handle = platform->func_load_texture(assets, DQN_STRING8("Hero"), sheet_path);
|
|
sheet->sprite_count = 109;
|
|
sheet->sprites_per_row = 7;
|
|
sheet->sprite_size = Dqn_V2I_InitNx2(50, 37);
|
|
|
|
TELY_AssetSpriteAnimation hero_anims[] = {
|
|
{DQN_STRING8("Everything"), /*index*/ 0, /*count*/ sheet->sprite_count, /*seconds_per_frame*/ 1 / 12.f},
|
|
{DQN_STRING8("Idle"), /*index*/ 0, /*count*/ 3, /*seconds_per_frame*/ 1 / 4.f},
|
|
{DQN_STRING8("Run"), /*index*/ 8, /*count*/ 6, /*seconds_per_frame*/ 1 / 8.f},
|
|
{DQN_STRING8("Jump"), /*index*/ 14, /*count*/ 10, /*seconds_per_frame*/ 1 / 12.f},
|
|
{DQN_STRING8("Floor slide"), /*index*/ 24, /*count*/ 5, /*seconds_per_frame*/ 1 / 12.f},
|
|
{DQN_STRING8("Unknown"), /*index*/ 29, /*count*/ 9, /*seconds_per_frame*/ 1 / 12.f},
|
|
{DQN_STRING8("Attack A"), /*index*/ 42, /*count*/ 7, /*seconds_per_frame*/ 1 / 12.f},
|
|
{DQN_STRING8("Attack B"), /*index*/ 49, /*count*/ 4, /*seconds_per_frame*/ 1 / 8.f},
|
|
{DQN_STRING8("Attack C"), /*index*/ 53, /*count*/ 6, /*seconds_per_frame*/ 1 / 12.f},
|
|
{DQN_STRING8("Hurt A"), /*index*/ 59, /*count*/ 5, /*seconds_per_frame*/ 1 / 12.f},
|
|
{DQN_STRING8("Hurt B"), /*index*/ 64, /*count*/ 5, /*seconds_per_frame*/ 1 / 12.f},
|
|
{DQN_STRING8("Unsheath sword"), /*index*/ 69, /*count*/ 4, /*seconds_per_frame*/ 1 / 12.f},
|
|
{DQN_STRING8("Sheath sword"), /*index*/ 73, /*count*/ 4, /*seconds_per_frame*/ 1 / 12.f},
|
|
{DQN_STRING8("Air drift"), /*index*/ 77, /*count*/ 2, /*seconds_per_frame*/ 1 / 12.f},
|
|
{DQN_STRING8("Air drop"), /*index*/ 79, /*count*/ 2, /*seconds_per_frame*/ 1 / 12.f},
|
|
{DQN_STRING8("Ladder climb"), /*index*/ 81, /*count*/ 4, /*seconds_per_frame*/ 1 / 12.f},
|
|
{DQN_STRING8("Chi push"), /*index*/ 85, /*count*/ 8, /*seconds_per_frame*/ 1 / 12.f},
|
|
{DQN_STRING8("Leap slice A"), /*index*/ 93, /*count*/ 7, /*seconds_per_frame*/ 1 / 12.f},
|
|
{DQN_STRING8("Leap slice B"), /*index*/ 100, /*count*/ 3, /*seconds_per_frame*/ 1 / 12.f},
|
|
{DQN_STRING8("Leap slice C"), /*index*/ 103, /*count*/ 6, /*seconds_per_frame*/ 1 / 12.f},
|
|
};
|
|
|
|
game->hero_sprite_anims = Dqn_Slice_Alloc<TELY_AssetSpriteAnimation>(&platform->arena, DQN_ARRAY_UCOUNT(hero_anims), Dqn_ZeroMem_No);
|
|
DQN_MEMCPY(game->hero_sprite_anims.data, &hero_anims, sizeof(hero_anims[0]) * DQN_ARRAY_UCOUNT(hero_anims));
|
|
}
|
|
|
|
// NOTE: Load sprite sheets ====================================================================
|
|
{
|
|
game->terry_sprite_sheet = FP_LoadSpriteSheetFromSpec(platform, assets, &platform->arena, DQN_STRING8("terry_resized_25%"));
|
|
game->terry_action_mappings = Dqn_Slice_CopyArray<FP_ActionToAnimationMapping>(&platform->arena, {
|
|
{&game->terry_sprite_sheet, TELY_Asset_GetSpriteAnimation(&game->terry_sprite_sheet, g_anim_names.terry_walk_idle)},
|
|
{&game->terry_sprite_sheet, TELY_Asset_GetSpriteAnimation(&game->terry_sprite_sheet, g_anim_names.terry_walk_up)},
|
|
{&game->terry_sprite_sheet, TELY_Asset_GetSpriteAnimation(&game->terry_sprite_sheet, g_anim_names.terry_walk_down)},
|
|
{&game->terry_sprite_sheet, TELY_Asset_GetSpriteAnimation(&game->terry_sprite_sheet, g_anim_names.terry_walk_left)},
|
|
{&game->terry_sprite_sheet, TELY_Asset_GetSpriteAnimation(&game->terry_sprite_sheet, g_anim_names.terry_walk_right)},
|
|
{&game->terry_sprite_sheet, TELY_Asset_GetSpriteAnimation(&game->terry_sprite_sheet, g_anim_names.terry_attack_up)},
|
|
{&game->terry_sprite_sheet, TELY_Asset_GetSpriteAnimation(&game->terry_sprite_sheet, g_anim_names.terry_attack_side)},
|
|
{&game->terry_sprite_sheet, TELY_Asset_GetSpriteAnimation(&game->terry_sprite_sheet, g_anim_names.terry_attack_down)},
|
|
});
|
|
|
|
game->terry_merchant_sprite_sheet = FP_LoadSpriteSheetFromSpec(platform, assets, &platform->arena, DQN_STRING8("terry_merchant_resized_25%"));
|
|
game->terry_merchant_action_mappings = Dqn_Slice_CopyArray<FP_ActionToAnimationMapping>(&platform->arena, {
|
|
{&game->terry_merchant_sprite_sheet, TELY_Asset_GetSpriteAnimation(&game->terry_merchant_sprite_sheet, g_anim_names.terry_merchant)},
|
|
});
|
|
|
|
game->smoochie_sprite_sheet = FP_LoadSpriteSheetFromSpec(platform, assets, &platform->arena, DQN_STRING8("smoochie_resized_25%"));
|
|
game->smoochie_action_mappings = Dqn_Slice_CopyArray<FP_ActionToAnimationMapping>(&platform->arena, {
|
|
{&game->smoochie_sprite_sheet, TELY_Asset_GetSpriteAnimation(&game->smoochie_sprite_sheet, g_anim_names.smoochie_walk_down)},
|
|
{&game->smoochie_sprite_sheet, TELY_Asset_GetSpriteAnimation(&game->smoochie_sprite_sheet, g_anim_names.smoochie_walk_up)},
|
|
{&game->smoochie_sprite_sheet, TELY_Asset_GetSpriteAnimation(&game->smoochie_sprite_sheet, g_anim_names.smoochie_walk_down)},
|
|
{&game->smoochie_sprite_sheet, TELY_Asset_GetSpriteAnimation(&game->smoochie_sprite_sheet, g_anim_names.smoochie_walk_left)},
|
|
{&game->smoochie_sprite_sheet, TELY_Asset_GetSpriteAnimation(&game->smoochie_sprite_sheet, g_anim_names.smoochie_walk_right)},
|
|
{&game->smoochie_sprite_sheet, TELY_Asset_GetSpriteAnimation(&game->smoochie_sprite_sheet, g_anim_names.smoochie_attack_down)},
|
|
{&game->smoochie_sprite_sheet, TELY_Asset_GetSpriteAnimation(&game->smoochie_sprite_sheet, g_anim_names.smoochie_attack_side)},
|
|
{&game->smoochie_sprite_sheet, TELY_Asset_GetSpriteAnimation(&game->smoochie_sprite_sheet, g_anim_names.smoochie_attack_heart)},
|
|
{&game->smoochie_sprite_sheet, TELY_Asset_GetSpriteAnimation(&game->smoochie_sprite_sheet, g_anim_names.smoochie_death)},
|
|
});
|
|
}
|
|
|
|
game->entities = Dqn_VArray_Init<FP_GameEntity>(&platform->arena, 1024 * 8);
|
|
game->root_entity = Dqn_VArray_Make(&game->entities, Dqn_ZeroMem_No);
|
|
Dqn_FArray_Add(&game->parent_entity_stack, game->root_entity->handle);
|
|
|
|
// NOTE: Hero
|
|
{
|
|
FP_GameEntity *entity = FP_Game_MakeEntityPointerF(game, "Terry");
|
|
entity->type = FP_EntityType_Terry;
|
|
entity->local_pos = Dqn_V2_InitNx2(1334, 396);
|
|
entity->action_to_anim_mapping = game->terry_action_mappings;
|
|
entity->size_scale = Dqn_V2_InitNx1(0.25f);
|
|
entity->local_hit_box_size = Dqn_V2_InitNx2(428, 471) * entity->size_scale;
|
|
entity->flags |= FP_GameEntityFlag_Clickable;
|
|
entity->flags |= FP_GameEntityFlag_MoveByKeyboard;
|
|
entity->flags |= FP_GameEntityFlag_MoveByMouse;
|
|
entity->flags |= FP_GameEntityFlag_MoveByGamepad;
|
|
entity->flags |= FP_GameEntityFlag_NonTraversable;
|
|
entity->direction = FP_GameDirection_Left;
|
|
game->clicked_entity = entity->handle;
|
|
game->player = entity->handle;
|
|
}
|
|
|
|
// NOTE: Merchant
|
|
{
|
|
FP_GameEntity *entity = FP_Game_MakeEntityPointerF(game, "Merchant");
|
|
entity->type = FP_EntityType_Merchant;
|
|
entity->local_pos = Dqn_V2_InitNx2(1000, 124);
|
|
entity->local_hit_box_size = Dqn_V2_InitNx2(50, 50);
|
|
entity->size_scale = Dqn_V2_InitNx1(0.25f);
|
|
entity->action_to_anim_mapping = game->terry_merchant_action_mappings;
|
|
entity->flags |= FP_GameEntityFlag_Clickable;
|
|
entity->flags |= FP_GameEntityFlag_MoveByKeyboard;
|
|
entity->flags |= FP_GameEntityFlag_MoveByMouse;
|
|
entity->flags |= FP_GameEntityFlag_MoveByGamepad;
|
|
entity->flags |= FP_GameEntityFlag_NonTraversable;
|
|
}
|
|
|
|
game->tile_size = 37;
|
|
Dqn_V2I max_tile = platform->core.window_size / game->tile_size;
|
|
|
|
// NOTE: Wall ==================================================================================
|
|
if (0) {
|
|
Dqn_V2I vert_wall_tile_size = Dqn_V2I_InitNx2(1, 12);
|
|
Dqn_V2I right_wall_tile_pos = Dqn_V2I_InitNx2(max_tile.x - vert_wall_tile_size.x - 0, (max_tile.y / 2.f) - (vert_wall_tile_size.y * .5f));
|
|
|
|
Dqn_V2I left_wall_top_tile = Dqn_V2I_InitNx2(max_tile.x - vert_wall_tile_size.x - 12, (max_tile.y / 2.f) - (vert_wall_tile_size.y * .5f));
|
|
Dqn_V2I left_wall_bottom_tile = Dqn_V2I_InitNx2(left_wall_top_tile.x, left_wall_top_tile.y + vert_wall_tile_size.y);
|
|
|
|
|
|
{
|
|
Dqn_V2I const vert_wall_part_tile_size = Dqn_V2I_InitNx2(1, (vert_wall_tile_size.y / 2) - 2);
|
|
FP_Game_EntityAddWallAtTile(game, DQN_STRING8("Base left-top wall"), left_wall_top_tile, vert_wall_part_tile_size);
|
|
|
|
Dqn_V2I bottom_part_tile = Dqn_V2I_InitNx2(left_wall_top_tile.x, left_wall_top_tile.y + vert_wall_tile_size.y - vert_wall_part_tile_size.y);
|
|
FP_Game_EntityAddWallAtTile(game, DQN_STRING8("Base left-bottom wall"), bottom_part_tile, vert_wall_part_tile_size);
|
|
}
|
|
|
|
FP_GameEntityHandle right_wall = FP_Game_EntityAddWallAtTile(game, DQN_STRING8("Base right wall"), right_wall_tile_pos, vert_wall_tile_size);
|
|
Dqn_Rect right_wall_box = FP_Game_CalcEntityWorldHitBox(game, right_wall);
|
|
Dqn_V2I right_wall_bottom_tile = FP_Game_WorldPosToTilePos(game, right_wall_box.pos + Dqn_V2_InitNx2(0, right_wall_box.size.y));
|
|
Dqn_V2I right_wall_top_left_tile = FP_Game_WorldPosToTilePos(game, right_wall_box.pos);
|
|
|
|
{
|
|
Dqn_V2I hori_wall_tile_size = Dqn_V2I_InitNx2((right_wall_tile_pos.x - left_wall_top_tile.x - 1) / 2 - 1, 1);
|
|
{
|
|
Dqn_V2I bottom_left_wall_tile_pos = Dqn_V2I_InitNx2(left_wall_bottom_tile.x + 1, left_wall_bottom_tile.y - 1);
|
|
FP_Game_EntityAddWallAtTile(game, DQN_STRING8("Base bottom-left wall"), bottom_left_wall_tile_pos, hori_wall_tile_size);
|
|
|
|
Dqn_V2I bottom_right_wall_tile_pos = Dqn_V2I_InitNx2(right_wall_bottom_tile.x - hori_wall_tile_size.x, right_wall_bottom_tile.y - 1);
|
|
FP_Game_EntityAddWallAtTile(game, DQN_STRING8("Base bottom-right wall"), bottom_right_wall_tile_pos, hori_wall_tile_size);
|
|
}
|
|
|
|
{
|
|
Dqn_V2I top_left_wall_tile_pos = Dqn_V2I_InitNx2(left_wall_top_tile.x + 1, left_wall_top_tile.y);
|
|
FP_Game_EntityAddWallAtTile(game, DQN_STRING8("Base top-left wall"), top_left_wall_tile_pos, hori_wall_tile_size);
|
|
|
|
Dqn_V2I top_right_wall_tile_pos = Dqn_V2I_InitNx2(right_wall_top_left_tile.x - hori_wall_tile_size.x, right_wall_top_left_tile.y);
|
|
FP_Game_EntityAddWallAtTile(game, DQN_STRING8("Base top-right wall"), top_right_wall_tile_pos, hori_wall_tile_size);
|
|
}
|
|
}
|
|
}
|
|
|
|
// NOTE: Mob spawner ===========================================================================
|
|
{
|
|
FP_GameEntity *entity = FP_Game_MakeEntityPointerF(game, "Mob spawner");
|
|
entity->local_pos = Dqn_V2_InitNx2(50.f, platform->core.window_size.y * .5f);
|
|
entity->flags |= FP_GameEntityFlag_Clickable;
|
|
entity->flags |= FP_GameEntityFlag_MoveByKeyboard;
|
|
entity->flags |= FP_GameEntityFlag_MoveByMouse;
|
|
entity->flags |= FP_GameEntityFlag_MoveByGamepad;
|
|
entity->flags |= FP_GameEntityFlag_MobSpawner;
|
|
|
|
entity->spawn_cap = 16;
|
|
entity->spawn_list = TELY_ChunkPool_New(game->chunk_pool, FP_GameEntitySpawnList);
|
|
entity->spawn_list->next = entity->spawn_list;
|
|
entity->spawn_list->prev = entity->spawn_list;
|
|
|
|
FP_Game_PushParentEntity(game, entity->handle);
|
|
{
|
|
{
|
|
FP_GameEntity *waypoint = FP_Game_MakeEntityPointerF(game, "Waypoint");
|
|
waypoint->local_pos = Dqn_V2_InitNx2(800.f, 100.f);
|
|
waypoint->flags |= FP_GameEntityFlag_Clickable;
|
|
waypoint->flags |= FP_GameEntityFlag_MoveByKeyboard;
|
|
waypoint->flags |= FP_GameEntityFlag_MoveByMouse;
|
|
waypoint->flags |= FP_GameEntityFlag_MoveByGamepad;
|
|
waypoint->flags |= FP_GameEntityFlag_MobSpawnerWaypoint;
|
|
}
|
|
}
|
|
FP_Game_PopParentEntity(game);
|
|
}
|
|
|
|
uint16_t font_size = 18;
|
|
game->camera.scale = Dqn_V2_InitNx1(1);
|
|
game->inter_regular_font = platform->func_load_font(assets, DQN_STRING8("Inter (Regular)"), DQN_STRING8("Data/Inter-Regular.otf"), font_size);
|
|
game->inter_italic_font = platform->func_load_font(assets, DQN_STRING8("Inter (Italic)"), DQN_STRING8("Data/Inter-Italic.otf"), font_size);
|
|
game->jetbrains_mono_font = platform->func_load_font(assets, DQN_STRING8("JetBrains Mono NL (Regular)"), DQN_STRING8("Data/JetBrainsMonoNL-Regular.ttf"), font_size);
|
|
game->test_audio = platform->func_load_audio(assets, DQN_STRING8("Test Audio"), DQN_STRING8("Data/Audio/Purrple Cat - Moonwinds.qoa"));
|
|
}
|
|
|
|
FP_ActionToAnimationMapping FP_Game_GetActionAnimMappingWithName(FP_Game *game, FP_GameEntityHandle entity_handle, Dqn_String8 name)
|
|
{
|
|
FP_GameEntity *entity = FP_Game_GetEntity(game, entity_handle);
|
|
FP_ActionToAnimationMapping result = {};
|
|
for (FP_ActionToAnimationMapping const &mapping : entity->action_to_anim_mapping) {
|
|
if (mapping.anim.label == name) {
|
|
result = mapping;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
FP_ActionToAnimationMapping FP_EntityActionStateMachine(FP_Game *game, TELY_PlatformInput *input, FP_GameEntity *entity, Dqn_V2 dir_vector)
|
|
{
|
|
FP_GameEntityAction *action = &entity->action;
|
|
bool we_are_clicked_entity = entity->handle == game->clicked_entity;
|
|
bool action_has_finished = action->timer_s != FP_GAME_ENTITY_ACTION_INFINITE_TIMER && action->timer_s >= action->end_at_s;
|
|
bool entity_has_velocity = entity->velocity.x || entity->velocity.y;
|
|
FP_ActionToAnimationMapping result = {};
|
|
|
|
switch (entity->type) {
|
|
case FP_EntityType_Terry: {
|
|
FP_EntityTerryState *state = DQN_CAST(FP_EntityTerryState *)&action->state;
|
|
if (*state == FP_EntityTerryState_Nil)
|
|
FP_Game_EntityActionSetState(action, FP_EntityTerryState_Idle);
|
|
|
|
if (*state == FP_EntityTerryState_Idle) {
|
|
result = FP_Game_GetActionAnimMappingWithName(game, entity->handle, g_anim_names.terry_walk_idle);
|
|
|
|
if (action->flags & FP_GameEntityActionFlag_StateTransition) {
|
|
FP_Game_EntityActionReset(action, FP_GAME_ENTITY_ACTION_INFINITE_TIMER, result);
|
|
} else if (we_are_clicked_entity) {
|
|
if (TELY_Platform_InputScanCodeIsPressed(input, TELY_PlatformInputScanCode_J) ||
|
|
TELY_Platform_InputGamepadButtonCodeIsPressed(input, 0, TELY_PlatformInputGamepadButtonCode_X)) {
|
|
switch (entity->direction) {
|
|
case FP_GameDirection_Up: {
|
|
FP_Game_EntityActionSetState(action, FP_EntityTerryState_AttackUp);
|
|
} break;
|
|
|
|
case FP_GameDirection_Left: {
|
|
FP_Game_EntityActionSetState(action, FP_EntityTerryState_AttackSide);
|
|
} break;
|
|
|
|
case FP_GameDirection_Right: {
|
|
FP_Game_EntityActionSetState(action, FP_EntityTerryState_AttackSide);
|
|
} break;
|
|
|
|
case FP_GameDirection_Down: {
|
|
FP_Game_EntityActionSetState(action, FP_EntityTerryState_AttackDown);
|
|
} break;
|
|
}
|
|
} else if (dir_vector.x || dir_vector.y) {
|
|
FP_Game_EntityActionSetState(action, FP_EntityTerryState_Run);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (*state == FP_EntityTerryState_AttackSide) {
|
|
result = FP_Game_GetActionAnimMappingWithName(game, entity->handle, g_anim_names.terry_attack_side);
|
|
action->flip_on_x = entity->direction == FP_GameDirection_Right;
|
|
|
|
if (action->flags & FP_GameEntityActionFlag_StateTransition) {
|
|
FP_Game_EntityActionReset(action, result.anim.count * result.anim.seconds_per_frame, result);
|
|
} else if (action_has_finished) {
|
|
FP_Game_EntityActionSetState(action, FP_EntityTerryState_Idle);
|
|
action->flip_on_x = false;
|
|
}
|
|
|
|
#if 0
|
|
else if (!FP_Game_EntityActionHasFailed(action) && we_are_clicked_entity) {
|
|
if (TELY_Platform_InputScanCodeIsPressed(input, TELY_PlatformInputScanCode_J) ||
|
|
TELY_Platform_InputGamepadButtonCodeIsPressed(input, 0, TELY_PlatformInputGamepadButtonCode_X)) {
|
|
Dqn_f32 t01 = action->timer_s / action->end_at_s;
|
|
if (t01 > 0.5f)
|
|
FP_Game_EntityActionSetState(action, FP_EntityTerryState_AttackB);
|
|
else
|
|
action->flags |= FP_GameEntityActionFlag_Failed;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
if (*state == FP_EntityTerryState_AttackUp) {
|
|
result = FP_Game_GetActionAnimMappingWithName(game, entity->handle, g_anim_names.terry_attack_up);
|
|
if (action->flags & FP_GameEntityActionFlag_StateTransition) {
|
|
FP_Game_EntityActionReset(action, result.anim.count * result.anim.seconds_per_frame, result);
|
|
} else if (action_has_finished) {
|
|
FP_Game_EntityActionSetState(action, FP_EntityTerryState_Idle);
|
|
}
|
|
}
|
|
|
|
if (*state == FP_EntityTerryState_AttackDown) {
|
|
result = FP_Game_GetActionAnimMappingWithName(game, entity->handle, g_anim_names.terry_attack_down);
|
|
if (action->flags & FP_GameEntityActionFlag_StateTransition) {
|
|
FP_Game_EntityActionReset(action, result.anim.count * result.anim.seconds_per_frame, result);
|
|
} else if (action_has_finished) {
|
|
FP_Game_EntityActionSetState(action, FP_EntityTerryState_Idle);
|
|
}
|
|
}
|
|
|
|
if (*state == FP_EntityTerryState_Run) {
|
|
Dqn_String8 desired_action_name = {};
|
|
switch (entity->direction) {
|
|
case FP_GameDirection_Up: desired_action_name = g_anim_names.terry_walk_up; break;
|
|
case FP_GameDirection_Down: desired_action_name = g_anim_names.terry_walk_down; break;
|
|
case FP_GameDirection_Left: desired_action_name = g_anim_names.terry_walk_left; break;
|
|
case FP_GameDirection_Right: desired_action_name = g_anim_names.terry_walk_right; break;
|
|
}
|
|
result = FP_Game_GetActionAnimMappingWithName(game, entity->handle, desired_action_name);
|
|
|
|
if (we_are_clicked_entity) {
|
|
if (TELY_Platform_InputScanCodeIsPressed(input, TELY_PlatformInputScanCode_J) ||
|
|
TELY_Platform_InputGamepadButtonCodeIsPressed(input, 0, TELY_PlatformInputGamepadButtonCode_X)) {
|
|
switch (entity->direction) {
|
|
case FP_GameDirection_Up: {
|
|
FP_Game_EntityActionSetState(action, FP_EntityTerryState_AttackUp);
|
|
} break;
|
|
|
|
case FP_GameDirection_Left: {
|
|
FP_Game_EntityActionSetState(action, FP_EntityTerryState_AttackSide);
|
|
} break;
|
|
|
|
case FP_GameDirection_Right: {
|
|
FP_Game_EntityActionSetState(action, FP_EntityTerryState_AttackSide);
|
|
} break;
|
|
|
|
case FP_GameDirection_Down: {
|
|
FP_Game_EntityActionSetState(action, FP_EntityTerryState_AttackDown);
|
|
} break;
|
|
}
|
|
} else if (TELY_Platform_InputScanCodeIsPressed(input, TELY_PlatformInputScanCode_LeftShift) ||
|
|
TELY_Platform_InputGamepadButtonCodeIsPressed(input, 0, TELY_PlatformInputGamepadButtonCode_A)) {
|
|
FP_Game_EntityActionSetState(action, FP_EntityTerryState_Dash);
|
|
}
|
|
}
|
|
|
|
// NOTE: Also handles state transition
|
|
if (action->mapping.anim.label != result.anim.label) {
|
|
FP_Game_EntityActionReset(action, FP_GAME_ENTITY_ACTION_INFINITE_TIMER, result);
|
|
}
|
|
|
|
if (!entity_has_velocity /*&& !has_collision*/) {
|
|
FP_Game_EntityActionSetState(action, FP_EntityTerryState_Idle);
|
|
}
|
|
}
|
|
|
|
if (*state == FP_EntityTerryState_Dash) {
|
|
result = FP_Game_GetActionAnimMappingWithName(game, entity->handle, g_anim_names.terry_walk_right);
|
|
|
|
if (action->flags & FP_GameEntityActionFlag_StateTransition) {
|
|
FP_Game_EntityActionReset(action, result.anim.count * result.anim.seconds_per_frame, result);
|
|
|
|
Dqn_V2 dash_dir = {};
|
|
switch (entity->direction) {
|
|
case FP_GameDirection_Up: dash_dir.y = -1.f; break;
|
|
case FP_GameDirection_Down: dash_dir.y = +1.f; break;
|
|
case FP_GameDirection_Left: dash_dir.x = -1.f; break;
|
|
case FP_GameDirection_Right: dash_dir.x = +1.f; break;
|
|
}
|
|
|
|
Dqn_V2 dash_acceleration = dash_dir * 400'000'000.f;
|
|
Dqn_f32 t = DQN_CAST(Dqn_f32)DQN_SQUARED(input->delta_s);
|
|
entity->velocity = (dash_acceleration * t) + entity->velocity * 2.0f;
|
|
|
|
} else if (action_has_finished) {
|
|
if (entity_has_velocity) {
|
|
// TODO(doyle): Not sure if this branch triggers properly.
|
|
FP_Game_EntityActionSetState(action, FP_EntityTerryState_Run);
|
|
} else {
|
|
FP_Game_EntityActionSetState(action, FP_EntityTerryState_Idle);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (*state == FP_EntityTerryState_AttackUp ||
|
|
*state == FP_EntityTerryState_AttackDown ||
|
|
*state == FP_EntityTerryState_AttackSide) {
|
|
entity->attack_box_size = entity->local_hit_box_size;
|
|
|
|
// NOTE: Position the attack box
|
|
if (entity->direction == FP_GameDirection_Left) {
|
|
entity->attack_box_offset = Dqn_V2_InitNx2(entity->local_hit_box_offset.x - entity->attack_box_size.w,
|
|
entity->local_hit_box_offset.y);
|
|
} else {
|
|
entity->attack_box_offset = Dqn_V2_InitNx2(entity->local_hit_box_offset.x + entity->local_hit_box_size.w,
|
|
entity->local_hit_box_offset.y);
|
|
}
|
|
} else {
|
|
entity->attack_box_size = {};
|
|
}
|
|
} break;
|
|
|
|
case FP_EntityType_Smoochie: {
|
|
FP_EntitySmoochieState *state = DQN_CAST(FP_EntitySmoochieState *)&action->state;
|
|
if (*state == FP_EntitySmoochieState_Nil)
|
|
FP_Game_EntityActionSetState(action, FP_EntitySmoochieState_Idle);
|
|
|
|
if (*state == FP_EntitySmoochieState_Idle) {
|
|
result = FP_Game_GetActionAnimMappingWithName(game, entity->handle, g_anim_names.smoochie_walk_down);
|
|
|
|
if (action->flags & FP_GameEntityActionFlag_StateTransition) {
|
|
FP_Game_EntityActionReset(action, FP_GAME_ENTITY_ACTION_INFINITE_TIMER, result);
|
|
} else if (we_are_clicked_entity) {
|
|
if (TELY_Platform_InputScanCodeIsPressed(input, TELY_PlatformInputScanCode_J) ||
|
|
TELY_Platform_InputGamepadButtonCodeIsPressed(input, 0, TELY_PlatformInputGamepadButtonCode_X)) {
|
|
|
|
switch (entity->direction) {
|
|
case FP_GameDirection_Up: /*FALLTHRU*/
|
|
case FP_GameDirection_Right: /*FALLTHRU*/
|
|
case FP_GameDirection_Left: {
|
|
FP_Game_EntityActionSetState(action, FP_EntitySmoochieState_AttackSide);
|
|
} break;
|
|
|
|
case FP_GameDirection_Down: {
|
|
FP_Game_EntityActionSetState(action, FP_EntitySmoochieState_AttackDown);
|
|
} break;
|
|
}
|
|
} else if (dir_vector.x || dir_vector.y) {
|
|
FP_Game_EntityActionSetState(action, FP_EntitySmoochieState_Run);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (*state == FP_EntitySmoochieState_AttackDown) {
|
|
result = FP_Game_GetActionAnimMappingWithName(game, entity->handle, g_anim_names.smoochie_attack_down);
|
|
if (action->flags & FP_GameEntityActionFlag_StateTransition) {
|
|
FP_Game_EntityActionReset(action, result.anim.count * result.anim.seconds_per_frame, result);
|
|
} else if (action_has_finished) {
|
|
FP_Game_EntityActionSetState(action, FP_EntitySmoochieState_Idle);
|
|
}
|
|
}
|
|
|
|
if (*state == FP_EntitySmoochieState_AttackSide) {
|
|
result = FP_Game_GetActionAnimMappingWithName(game, entity->handle, g_anim_names.smoochie_attack_side);
|
|
action->flip_on_x = entity->direction == FP_GameDirection_Right;
|
|
if (action->flags & FP_GameEntityActionFlag_StateTransition) {
|
|
FP_Game_EntityActionReset(action, result.anim.count * result.anim.seconds_per_frame, result);
|
|
} else if (action_has_finished) {
|
|
FP_Game_EntityActionSetState(action, FP_EntitySmoochieState_Idle);
|
|
action->flip_on_x = false;
|
|
}
|
|
}
|
|
|
|
if (*state == FP_EntitySmoochieState_Run) {
|
|
Dqn_String8 desired_action_name = {};
|
|
switch (entity->direction) {
|
|
case FP_GameDirection_Up: desired_action_name = g_anim_names.smoochie_walk_up; break;
|
|
case FP_GameDirection_Down: desired_action_name = g_anim_names.smoochie_walk_down; break;
|
|
case FP_GameDirection_Left: desired_action_name = g_anim_names.smoochie_walk_left; break;
|
|
case FP_GameDirection_Right: desired_action_name = g_anim_names.smoochie_walk_right; break;
|
|
}
|
|
result = FP_Game_GetActionAnimMappingWithName(game, entity->handle, desired_action_name);
|
|
|
|
if (we_are_clicked_entity) {
|
|
if (TELY_Platform_InputScanCodeIsPressed(input, TELY_PlatformInputScanCode_J) ||
|
|
TELY_Platform_InputGamepadButtonCodeIsPressed(input, 0, TELY_PlatformInputGamepadButtonCode_X)) {
|
|
|
|
switch (entity->direction) {
|
|
case FP_GameDirection_Up: /*FALLTHRU*/
|
|
case FP_GameDirection_Right: /*FALLTHRU*/
|
|
case FP_GameDirection_Left: {
|
|
FP_Game_EntityActionSetState(action, FP_EntitySmoochieState_AttackSide);
|
|
} break;
|
|
|
|
case FP_GameDirection_Down: {
|
|
FP_Game_EntityActionSetState(action, FP_EntitySmoochieState_AttackDown);
|
|
} break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// NOTE: Also handles state transition
|
|
if (action->mapping.anim.label != result.anim.label) {
|
|
FP_Game_EntityActionReset(action, FP_GAME_ENTITY_ACTION_INFINITE_TIMER, result);
|
|
}
|
|
|
|
if (!entity_has_velocity /*&& !has_collision*/) {
|
|
FP_Game_EntityActionSetState(action, FP_EntitySmoochieState_Idle);
|
|
}
|
|
}
|
|
|
|
if (*state == FP_EntitySmoochieState_AttackSide || *state == FP_EntitySmoochieState_AttackDown) {
|
|
entity->attack_box_size = entity->local_hit_box_size;
|
|
// NOTE: Position the attack box
|
|
if (entity->direction == FP_GameDirection_Left) {
|
|
entity->attack_box_offset = Dqn_V2_InitNx2(entity->local_hit_box_offset.x - entity->attack_box_size.w,
|
|
entity->local_hit_box_offset.y);
|
|
} else {
|
|
entity->attack_box_offset = Dqn_V2_InitNx2(entity->local_hit_box_offset.x + entity->local_hit_box_size.w,
|
|
entity->local_hit_box_offset.y);
|
|
}
|
|
} else {
|
|
entity->attack_box_size = {};
|
|
}
|
|
|
|
} break;
|
|
|
|
case FP_EntityType_Merchant: {
|
|
FP_EntityTerryMerchantState *state = DQN_CAST(FP_EntityTerryMerchantState *)&action->state;
|
|
if (*state == FP_EntityTerryMerchantState_Nil)
|
|
FP_Game_EntityActionSetState(action, FP_EntityTerryMerchantState_Idle);
|
|
|
|
if (*state == FP_EntityTerryMerchantState_Idle) {
|
|
result = FP_Game_GetActionAnimMappingWithName(game, entity->handle, g_anim_names.terry_merchant);
|
|
if (action->flags & FP_GameEntityActionFlag_StateTransition) {
|
|
FP_Game_EntityActionReset(action, FP_GAME_ENTITY_ACTION_INFINITE_TIMER, result);
|
|
}
|
|
}
|
|
} break;
|
|
}
|
|
|
|
// NOTE: Tick entity action ================================================================
|
|
action->timer_s += DQN_CAST(Dqn_f32)input->delta_s;
|
|
return result;
|
|
}
|
|
|
|
void FP_Update(TELY_Platform *platform, FP_Game *game, TELY_Renderer *renderer, TELY_PlatformInput *input)
|
|
{
|
|
Dqn_Profiler_ZoneScopeWithIndex("FP_Update", FP_ProfileZone_FPUpdate);
|
|
|
|
if (TELY_Platform_InputKeyIsReleased(input->mouse_left))
|
|
game->clicked_entity = game->prev_active_entity;
|
|
|
|
Dqn_V2 dir_vector = {};
|
|
|
|
// NOTE: Keyboard movement input
|
|
if (TELY_Platform_InputScanCodeIsDown(input, TELY_PlatformInputScanCode_W))
|
|
dir_vector.y = -1.f;
|
|
if (TELY_Platform_InputScanCodeIsDown(input, TELY_PlatformInputScanCode_A))
|
|
dir_vector.x = -1.f;
|
|
if (TELY_Platform_InputScanCodeIsDown(input, TELY_PlatformInputScanCode_S))
|
|
dir_vector.y = +1.f;
|
|
if (TELY_Platform_InputScanCodeIsDown(input, TELY_PlatformInputScanCode_D))
|
|
dir_vector.x = +1.f;
|
|
|
|
// NOTE: Gamepad movement input
|
|
// NOTE: button_codes 0 should be the first gamepad connected, we can
|
|
// get this working with other gamepads later
|
|
uint32_t gamepad = 0;
|
|
if (input->button_codes[gamepad]) {
|
|
dir_vector.x += input->left_stick[gamepad].x;
|
|
dir_vector.y += input->left_stick[gamepad].y;
|
|
}
|
|
|
|
if (dir_vector.x && dir_vector.y) {
|
|
dir_vector.x *= 0.7071067811865475244f;
|
|
dir_vector.y *= 0.7071067811865475244f;
|
|
}
|
|
|
|
if (game->clicked_entity.id) {
|
|
if (TELY_Platform_InputScanCodeIsPressed(input, TELY_PlatformInputScanCode_Delete))
|
|
FP_Game_DeleteEntity(game, game->clicked_entity);
|
|
} else {
|
|
game->camera.world_pos += dir_vector * 5.f;
|
|
}
|
|
|
|
Dqn_ProfilerZone update_zone = Dqn_Profiler_BeginZoneWithIndex(DQN_STRING8("FP_Update: Entity loop"), FP_ProfileZone_FPUpdate_EntityLoop);
|
|
for (FP_GameEntityIterator it = {}; FP_Game_DFSPostOrderWalkEntityTree(game, &it, game->root_entity); ) {
|
|
FP_GameEntity *entity = it.entity;
|
|
entity->alive_time_s += input->delta_s;
|
|
|
|
// NOTE: Move entity by keyboard and gamepad ===============================================
|
|
Dqn_V2 acceleration = {};
|
|
if (game->clicked_entity == entity->handle) {
|
|
if (entity->flags & (FP_GameEntityFlag_MoveByKeyboard | FP_GameEntityFlag_MoveByGamepad)) {
|
|
bool move_entity = false;
|
|
switch (entity->type) {
|
|
case FP_EntityType_Terry: {
|
|
FP_EntityTerryState *state = DQN_CAST(FP_EntityTerryState *)&entity->action.state;
|
|
move_entity = *state == FP_EntityTerryState_Run || *state == FP_EntityTerryState_Idle;
|
|
} break;
|
|
|
|
case FP_EntityType_Smoochie: {
|
|
FP_EntitySmoochieState *state = DQN_CAST(FP_EntitySmoochieState *)&entity->action.state;
|
|
move_entity = *state == FP_EntitySmoochieState_Run || *state == FP_EntitySmoochieState_Idle;
|
|
} break;
|
|
|
|
case FP_EntityType_Merchant: break;
|
|
}
|
|
|
|
if (move_entity) {
|
|
acceleration = dir_vector * 10000000.f;
|
|
if (dir_vector.x)
|
|
entity->direction = dir_vector.x > 0.f ? FP_GameDirection_Right : FP_GameDirection_Left;
|
|
else if (dir_vector.y)
|
|
entity->direction = dir_vector.y > 0.f ? FP_GameDirection_Down : FP_GameDirection_Up;
|
|
}
|
|
}
|
|
}
|
|
|
|
// NOTE: Stalk entity ======================================================================
|
|
Dqn_V2 entity_world_pos = FP_Game_CalcEntityWorldPos(game, entity->handle);
|
|
#if 0
|
|
{
|
|
FP_GameEntity *stalk_entity = FP_Game_GetEntity(game, entity->stalk_entity);
|
|
if (stalk_entity->handle.id) {
|
|
Dqn_Profiler_ZoneScopeWithIndex("FP_Update: Path finding", FP_ProfileZone_FPUpdate_PathFinding);
|
|
Dqn_V2 stalk_world_pos = FP_Game_CalcEntityWorldPos(game, stalk_entity->handle);
|
|
Dqn_V2I stalk_tile = Dqn_V2I_InitNx2(stalk_world_pos.x / game->tile_size, stalk_world_pos.y / game->tile_size);
|
|
if (entity->stalk_entity_last_known_tile != stalk_tile) {
|
|
entity->stalk_entity_last_known_tile = stalk_tile;
|
|
|
|
// NOTE: Dealloc all waypoints
|
|
for (FP_GameWaypoint *waypoint = entity->waypoints->next; waypoint != entity->waypoints; ) {
|
|
FP_GameWaypoint *next = waypoint->next;
|
|
TELY_ChunkPool_Dealloc(game->chunk_pool, waypoint);
|
|
waypoint = next;
|
|
}
|
|
entity->waypoints->next = entity->waypoints;
|
|
entity->waypoints->prev = entity->waypoints;
|
|
|
|
Dqn_Slice<Dqn_V2I> path_find = FP_Game_AStarPathFind(game, &platform->frame_arena, platform, entity->handle, stalk_tile);
|
|
for (Dqn_usize index = path_find.size - 1; index < path_find.size; index--) {
|
|
FP_GameWaypoint *waypoint = TELY_ChunkPool_New(game->chunk_pool, FP_GameWaypoint);
|
|
waypoint->pos = path_find.data[index];
|
|
waypoint->next = entity->waypoints;
|
|
waypoint->prev = entity->waypoints->prev;
|
|
waypoint->next->prev = waypoint;
|
|
waypoint->prev->next = waypoint;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// NOTE: Render the waypoints
|
|
for (FP_GameWaypoint *waypoint = entity->waypoints->next; waypoint != entity->waypoints; waypoint = waypoint->next) {
|
|
Dqn_V2 circle_pos = Dqn_V2_InitNx2(waypoint->pos.x, waypoint->pos.y);
|
|
TELY_Render_CircleColourV4(renderer, circle_pos, 4.f, TELY_RenderShapeMode_Fill, TELY_COLOUR_MAGENTA_V4);
|
|
}
|
|
|
|
if (entity->waypoints->next != entity->waypoints) {
|
|
FP_GameWaypoint *waypoint = entity->waypoints->next;
|
|
Dqn_V2 target_pos = Dqn_V2_InitV2I(entity->waypoints->next->pos);
|
|
Dqn_V2 entity_to_target_pos = target_pos - entity_world_pos;
|
|
|
|
if (Dqn_V2_LengthSq(entity_to_target_pos) < DQN_SQUARED(entity->local_hit_box_size.x * .5f)) {
|
|
waypoint->next->prev = waypoint->prev;
|
|
waypoint->prev->next = waypoint->next;
|
|
TELY_ChunkPool_Dealloc(game->chunk_pool, waypoint);
|
|
} else {
|
|
Dqn_V2 entity_to_target_pos_norm = Dqn_V2_Normalise(entity_to_target_pos);
|
|
if (acceleration.x == 0 && acceleration.y == 0) {
|
|
acceleration = entity_to_target_pos_norm * 1'000'000.f;
|
|
}
|
|
}
|
|
}
|
|
|
|
// NOTE: Core equations of motion ==========================================================
|
|
bool has_collision = false;
|
|
{
|
|
// f"(t) = a
|
|
// f'(t) = at + v
|
|
// f (t) = 0.5f*a(t^2) + vt + p
|
|
Dqn_f32 t = DQN_CAST(Dqn_f32)DQN_SQUARED(input->delta_s);
|
|
Dqn_f32 t_squared = DQN_SQUARED(t);
|
|
|
|
Dqn_f32 velocity_falloff_coefficient = 0.25f;
|
|
if (entity->handle == game->clicked_entity) {
|
|
if (dir_vector.x || dir_vector.y)
|
|
velocity_falloff_coefficient = 0.82f;
|
|
}
|
|
|
|
entity->velocity = (acceleration * t) + entity->velocity * velocity_falloff_coefficient;
|
|
|
|
// NOTE: Zero out velocity with epsilon
|
|
if (DQN_ABS(entity->velocity.x) < 5.f)
|
|
entity->velocity.x = 0.f;
|
|
if (DQN_ABS(entity->velocity.y) < 5.f)
|
|
entity->velocity.y = 0.f;
|
|
|
|
Dqn_V2 delta_pos = (acceleration * 0.5f * t_squared) + (entity->velocity * t);
|
|
|
|
Dqn_Rect entity_world_hit_box = FP_Game_CalcEntityWorldHitBox(game, entity->handle);
|
|
Dqn_V2 entity_pos = Dqn_Rect_Center(entity_world_hit_box);
|
|
Dqn_V2 entity_new_pos = entity_pos + delta_pos;
|
|
|
|
for (FP_GameEntityIterator collider_it = {}; FP_Game_DFSPostOrderWalkEntityTree(game, &collider_it, game->root_entity); ) {
|
|
FP_GameEntity *collider = collider_it.entity;
|
|
if (collider->handle == entity->handle)
|
|
continue;
|
|
|
|
// NOTE: Sweep collider with half the radius of the source entity
|
|
Dqn_Rect collider_world_hit_box = FP_Game_CalcEntityWorldHitBox(game, collider->handle);
|
|
Dqn_Rect swept_collider_world_hit_box = collider_world_hit_box;
|
|
swept_collider_world_hit_box.pos -= (entity_world_hit_box.size * .5f);
|
|
swept_collider_world_hit_box.size += entity_world_hit_box.size;
|
|
|
|
if (!Dqn_Rect_ContainsPoint(swept_collider_world_hit_box, entity_new_pos))
|
|
continue;
|
|
|
|
Dqn_f32 collider_left_wall_x = swept_collider_world_hit_box.pos.x;
|
|
Dqn_f32 collider_right_wall_x = swept_collider_world_hit_box.pos.x + swept_collider_world_hit_box.size.w;
|
|
Dqn_f32 collider_top_wall_y = swept_collider_world_hit_box.pos.y;
|
|
Dqn_f32 collider_bottom_wall_y = swept_collider_world_hit_box.pos.y + swept_collider_world_hit_box.size.h;
|
|
|
|
Dqn_V2 o = entity_pos;
|
|
Dqn_V2 d = delta_pos;
|
|
|
|
// NOTE: Solve collision by determining the 't' value at which
|
|
// we hit one of the walls of the collider and move the entity
|
|
// at exactly that point.
|
|
// O + td = x
|
|
// td = x - O
|
|
// t = (x - O) / d
|
|
|
|
Dqn_f32 const SENTINEL_T = 999.f;
|
|
Dqn_f32 earliest_t = SENTINEL_T;
|
|
if (d.x != 0.f) {
|
|
Dqn_f32 left_t = (collider_left_wall_x - o.x) / d.x;
|
|
Dqn_f32 right_t = (collider_right_wall_x - o.x) / d.x;
|
|
if (left_t >= 0.f && left_t <= 1.f)
|
|
earliest_t = DQN_MIN(earliest_t, left_t);
|
|
if (right_t >= 0.f && right_t <= 1.f)
|
|
earliest_t = DQN_MIN(earliest_t, right_t);
|
|
}
|
|
|
|
if (d.y != 0.f) {
|
|
Dqn_f32 top_t = (collider_top_wall_y - o.y) / d.y;
|
|
Dqn_f32 bottom_t = (collider_bottom_wall_y - o.y) / d.y;
|
|
if (top_t >= 0.f && top_t <= 1.f)
|
|
earliest_t = DQN_MIN(earliest_t, top_t);
|
|
if (bottom_t >= 0.f && bottom_t <= 1.f)
|
|
earliest_t = DQN_MIN(earliest_t, bottom_t);
|
|
}
|
|
|
|
if (earliest_t != SENTINEL_T) {
|
|
Dqn_V2 pos_just_before_collide = entity_pos + (d * earliest_t);
|
|
Dqn_V2 new_delta_p = pos_just_before_collide - entity_pos;
|
|
entity->local_pos += new_delta_p;
|
|
has_collision = true;
|
|
}
|
|
}
|
|
|
|
if (!has_collision) {
|
|
entity->local_pos += delta_pos;
|
|
}
|
|
}
|
|
|
|
// NOTE: Move entity by mouse ==============================================================
|
|
if (game->active_entity == entity->handle && entity->flags & FP_GameEntityFlag_MoveByMouse) {
|
|
if (entity->flags & FP_GameEntityFlag_MoveByMouse) {
|
|
entity->velocity = {};
|
|
entity->local_pos += input->mouse_p_delta;
|
|
}
|
|
}
|
|
|
|
if (entity->flags & FP_GameEntityFlag_DeriveHitBoxFromChildrenBoundingBox) {
|
|
Dqn_Rect children_bbox = {};
|
|
|
|
// TODO(doyle): Is the hit box supposed to include the containing
|
|
// entity itself? Not sure
|
|
children_bbox.pos = FP_Game_CalcEntityWorldPos(game, entity->handle);
|
|
|
|
for (FP_GameEntityIterator child_it = {}; FP_Game_DFSPreOrderWalkEntityTree(game, &child_it, entity);) {
|
|
FP_GameEntity *child = child_it.entity;
|
|
DQN_ASSERT(child != entity);
|
|
|
|
Dqn_Rect bbox = FP_Game_CalcEntityWorldBoundingBox(game, child->handle);
|
|
children_bbox = Dqn_Rect_Union(children_bbox, bbox);
|
|
}
|
|
|
|
Dqn_Rect padded_bbox = Dqn_Rect_Expand(children_bbox, 16.f);
|
|
entity->local_hit_box_offset = padded_bbox.pos - entity->local_pos + (padded_bbox.size * .5f);
|
|
entity->local_hit_box_size = padded_bbox.size;
|
|
}
|
|
|
|
// NOTE: Handle input on entity ============================================================
|
|
FP_ActionToAnimationMapping action_to_anim_mapping = FP_EntityActionStateMachine(game, input, entity, dir_vector);
|
|
|
|
// NOTE: Mob spawner =======================================================================
|
|
if (entity->flags & FP_GameEntityFlag_MobSpawner) {
|
|
// NOTE: Check if any spawned entities dies to remove it from the spawn cap tracker
|
|
for (FP_GameEntitySpawnList *link = entity->spawn_list->next; link != entity->spawn_list;) {
|
|
FP_GameEntity *spawned_entity = FP_Game_GetEntity(game, link->entity);
|
|
if (spawned_entity) {
|
|
// NOTE: Spawned entity is still alive
|
|
link = link->next;
|
|
continue;
|
|
}
|
|
|
|
DQN_ASSERT(entity->spawn_count);
|
|
entity->spawn_count--;
|
|
|
|
// NOTE: Entity is dead remove it from the linked list
|
|
FP_GameEntitySpawnList *link_to_delete = link;
|
|
link->next->prev = link->prev;
|
|
link->prev->next = link->next;
|
|
link = link->next;
|
|
TELY_ChunkPool_Dealloc(game->chunk_pool, link_to_delete);
|
|
}
|
|
|
|
if (entity->spawn_count < entity->spawn_cap) { // NOTE: Spawn new entities
|
|
if (input->timer_s >= entity->next_spawn_timestamp_s) {
|
|
entity->next_spawn_timestamp_s = DQN_CAST(uint64_t)(input->timer_s + 5.f);
|
|
entity->spawn_count++;
|
|
|
|
FP_GameEntitySpawnList *item = TELY_ChunkPool_New(game->chunk_pool, FP_GameEntitySpawnList);
|
|
item->entity = FP_Game_EntityAddMob(game, entity_world_pos);
|
|
FP_SentinelDoublyLinkedList_Insert(entity->spawn_list, item);
|
|
|
|
// NOTE: Setup the mob with a sentinel waypoint
|
|
FP_GameEntity *mob = FP_Game_GetEntity(game, item->entity);
|
|
mob->waypoints = TELY_ChunkPool_New(game->chunk_pool, FP_GameWaypoint);
|
|
mob->waypoints->next = mob->waypoints;
|
|
mob->waypoints->prev = mob->waypoints;
|
|
|
|
for (FP_GameEntity *waypoint_entity = entity->first_child; waypoint_entity; waypoint_entity = waypoint_entity->next) {
|
|
if ((waypoint_entity->flags & FP_GameEntityFlag_MobSpawnerWaypoint) == 0)
|
|
continue;
|
|
|
|
// NOTE: Add the waypoint
|
|
FP_GameWaypoint *waypoint = TELY_ChunkPool_New(game->chunk_pool, FP_GameWaypoint);
|
|
Dqn_V2 waypoint_pos = FP_Game_CalcEntityWorldPos(game, waypoint_entity->handle);
|
|
waypoint->pos = Dqn_V2I_InitV2(waypoint_pos);
|
|
FP_SentinelDoublyLinkedList_Insert(mob->waypoints, waypoint);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Dqn_Profiler_EndZone(update_zone);
|
|
|
|
// NOTE: Do attacks ============================================================================
|
|
auto attack_zone = Dqn_Profiler_BeginZoneWithIndex(DQN_STRING8("FP_Update: Attacks"), FP_ProfileZone_FPUpdate_Attacks);
|
|
for (FP_GameEntityIterator attacker_it = {}; FP_Game_DFSPostOrderWalkEntityTree(game, &attacker_it, game->root_entity); ) {
|
|
FP_GameEntity *attacker = attacker_it.entity;
|
|
|
|
// NOTE: Resolve attack boxes
|
|
if (!Dqn_V2_Area(attacker->attack_box_size))
|
|
continue;
|
|
|
|
Dqn_Rect attacker_box = FP_Game_CalcEntityAttackWorldHitBox(game, attacker->handle);
|
|
Dqn_V2 attacker_world_pos = FP_Game_CalcEntityWorldPos(game, attacker->handle);
|
|
|
|
for (FP_GameEntityIterator defender_it = {}; FP_Game_DFSPostOrderWalkEntityTree(game, &defender_it, game->root_entity); ) {
|
|
FP_GameEntity *defender = defender_it.entity;
|
|
if (defender->handle == attacker->handle)
|
|
continue;
|
|
|
|
Dqn_Rect defender_box = FP_Game_CalcEntityWorldHitBox(game, defender->handle);
|
|
if (!Dqn_Rect_Intersects(attacker_box, defender_box))
|
|
continue;
|
|
|
|
Dqn_V2 defender_world_pos = Dqn_Rect_Center(defender_box);
|
|
Dqn_V2 attack_dir_vector = {};
|
|
if (attacker_world_pos.x < defender_world_pos.x)
|
|
attack_dir_vector.x = 1.f;
|
|
else
|
|
attack_dir_vector.x = -1.f;
|
|
|
|
Dqn_V2 acceleration = attack_dir_vector * 500'000.f;
|
|
Dqn_f32 t = DQN_CAST(Dqn_f32)DQN_SQUARED(input->delta_s);
|
|
Dqn_f32 t_squared = DQN_SQUARED(t);
|
|
|
|
Dqn_V2 delta_p = (acceleration * 0.5f * t_squared) + (defender->velocity * t);
|
|
defender->velocity = (acceleration * t) + defender->velocity * 2.0f;
|
|
}
|
|
}
|
|
Dqn_Profiler_EndZone(attack_zone);
|
|
}
|
|
|
|
void FP_Render(FP_Game *game, TELY_Platform *platform, TELY_Renderer *renderer)
|
|
{
|
|
Dqn_Profiler_ZoneScopeWithIndex("FP_Render", FP_ProfileZone_FPRender);
|
|
TELY_PlatformInput *input = &platform->input;
|
|
Dqn_M2x3 model_view = FP_Game_CameraModelViewM2x3(game->camera, platform);
|
|
Dqn_V2 world_mouse_p = Dqn_M2x3_MulV2(model_view, input->mouse_p);
|
|
|
|
// NOTE: Draw tiles ============================================================================
|
|
Dqn_usize tile_count_x = DQN_CAST(Dqn_usize)(platform->core.window_size.w / game->tile_size);
|
|
Dqn_usize tile_count_y = DQN_CAST(Dqn_usize)(platform->core.window_size.h / game->tile_size);
|
|
|
|
for (Dqn_usize x = 0; x < tile_count_x; x++) {
|
|
Dqn_V2 start = Dqn_V2_InitNx2((x + 1) * game->tile_size, 0);
|
|
Dqn_V2 end = Dqn_V2_InitNx2(start.x, platform->core.window_size.h);
|
|
TELY_Render_LineColourV4(renderer, start, end, TELY_Colour_V4Alpha(TELY_COLOUR_WHITE_V4, .25f), 1.f);
|
|
}
|
|
|
|
for (Dqn_usize y = 0; y < tile_count_y; y++) {
|
|
Dqn_V2 start = Dqn_V2_InitNx2(0, (y + 1) * game->tile_size);
|
|
Dqn_V2 end = Dqn_V2_InitNx2(platform->core.window_size.w, start.y);
|
|
TELY_Render_LineColourV4(renderer, start, end, TELY_Colour_V4Alpha(TELY_COLOUR_WHITE_V4, .25f), 1.f);
|
|
}
|
|
|
|
// NOTE: Draw entities =========================================================================
|
|
for (FP_GameEntityIterator it = {}; FP_Game_DFSPostOrderWalkEntityTree(game, &it, game->root_entity); ) {
|
|
FP_GameEntity *entity = it.entity;
|
|
entity->alive_time_s += input->delta_s;
|
|
|
|
// NOTE: Render shapes in entity ===========================================================
|
|
Dqn_V2 world_pos = FP_Game_CalcEntityWorldPos(game, entity->handle);
|
|
for (FP_GameShape const &shape_ : entity->shapes) {
|
|
FP_GameShape const *shape = &shape_;
|
|
Dqn_V2 local_to_world_p1 = world_pos + shape->p1;
|
|
Dqn_V2 local_to_world_p2 = world_pos + shape->p2;
|
|
switch (shape->type) {
|
|
case FP_GameShapeType_None: {
|
|
} break;
|
|
|
|
case FP_GameShapeType_Circle: {
|
|
TELY_Render_CircleColourV4(renderer, local_to_world_p1, shape->circle_radius, shape->render_mode, shape->colour);
|
|
} break;
|
|
|
|
case FP_GameShapeType_Rect: {
|
|
Dqn_Rect rect = Dqn_Rect_InitV2x2(local_to_world_p1, local_to_world_p2 - local_to_world_p1);
|
|
rect.pos -= rect.size * .5f;
|
|
TELY_Render_RectColourV4(renderer, rect, shape->render_mode, shape->colour);
|
|
} break;
|
|
|
|
case FP_GameShapeType_Line: {
|
|
TELY_Render_LineColourV4(renderer, local_to_world_p1, local_to_world_p2, shape->colour, shape->line_thickness);
|
|
} break;
|
|
}
|
|
}
|
|
|
|
// NOTE: Render entity sprites =============================================================
|
|
if (entity->action.mapping.anim.label.size) {
|
|
FP_GameEntityAction const *action = &entity->action;
|
|
TELY_AssetSpriteSheet const *sprite_sheet = action->mapping.sheet;
|
|
TELY_AssetSpriteAnimation const *sprite_anim = &action->mapping.anim;
|
|
uint16_t anim_frame = DQN_CAST(uint16_t)(action->timer_s / sprite_anim->seconds_per_frame) % sprite_anim->count;
|
|
|
|
Dqn_usize sprite_index = sprite_anim->index + anim_frame;
|
|
Dqn_Rect src_rect = {};
|
|
switch (sprite_sheet->type) {
|
|
case TELY_AssetSpriteSheetType_Uniform: {
|
|
Dqn_usize sprite_sheet_row = sprite_index / sprite_sheet->sprites_per_row;
|
|
Dqn_usize sprite_sheet_column = sprite_index % sprite_sheet->sprites_per_row;
|
|
src_rect.pos.x = DQN_CAST(Dqn_f32)(sprite_sheet_column * sprite_sheet->sprite_size.w);
|
|
src_rect.pos.y = DQN_CAST(Dqn_f32)(sprite_sheet_row * sprite_sheet->sprite_size.y);
|
|
src_rect.size.w = DQN_CAST(Dqn_f32)sprite_sheet->sprite_size.w;
|
|
src_rect.size.h = DQN_CAST(Dqn_f32)sprite_sheet->sprite_size.h;
|
|
} break;
|
|
|
|
case TELY_AssetSpriteSheetType_Rects: {
|
|
DQN_ASSERT(sprite_index < sprite_sheet->rects.size);
|
|
src_rect = sprite_sheet->rects.data[sprite_index];
|
|
} break;
|
|
}
|
|
|
|
Dqn_Rect dest_rect = {};
|
|
dest_rect.size = src_rect.size * entity->size_scale;
|
|
dest_rect.pos = world_pos - (dest_rect.size * .5f);
|
|
|
|
if (action->flip_on_x)
|
|
dest_rect.size.w *= -1.f; // NOTE: Flip the texture horizontally
|
|
|
|
TELY_Render_TextureColourV4(renderer, sprite_sheet->tex_handle, src_rect, dest_rect, TELY_COLOUR_WHITE_V4);
|
|
}
|
|
|
|
// NOTE: Render attack box =================================================================
|
|
{
|
|
Dqn_Rect attack_box = FP_Game_CalcEntityAttackWorldHitBox(game, entity->handle);
|
|
TELY_Render_RectColourV4(renderer, attack_box, TELY_RenderShapeMode_Line, TELY_COLOUR_RED_TOMATO_V4);
|
|
}
|
|
|
|
// NOTE: Render world position =============================================================
|
|
TELY_Render_CircleColourV4(renderer, world_pos, 4.f, TELY_RenderShapeMode_Fill, TELY_COLOUR_RED_TOMATO_V4);
|
|
|
|
// NOTE: Render hot/active entity ==========================================================
|
|
Dqn_Rect world_hit_box = FP_Game_CalcEntityWorldHitBox(game, entity->handle);
|
|
if (game->clicked_entity == entity->handle) {
|
|
TELY_Render_RectColourV4(renderer, world_hit_box, TELY_RenderShapeMode_Line, TELY_COLOUR_WHITE_PALE_GOLDENROD_V4);
|
|
} else if (game->hot_entity == entity->handle || (entity->flags & FP_GameEntityFlag_DrawHitBox)) {
|
|
Dqn_V4 hot_colour = game->hot_entity == entity->handle ? TELY_COLOUR_RED_TOMATO_V4 : TELY_Colour_V4Alpha(TELY_COLOUR_YELLOW_SANDY_V4, .5f);
|
|
TELY_Render_RectColourV4(renderer, world_hit_box, TELY_RenderShapeMode_Line, hot_colour);
|
|
}
|
|
|
|
if (game->hot_entity == entity->handle) {
|
|
if (entity->name.size) {
|
|
Dqn_V2I player_tile = Dqn_V2I_InitNx2(world_pos.x / game->tile_size, world_pos.y / game->tile_size);
|
|
Dqn_V2 entity_world_pos = FP_Game_CalcEntityWorldPos(game, entity->handle);
|
|
Dqn_ThreadScratch scratch = Dqn_Thread_GetScratch(nullptr);
|
|
Dqn_String8 label = Dqn_String8_InitF(scratch.allocator,
|
|
"%.*s (%.1f, %.1f) (%I32d, %I32d)",
|
|
DQN_STRING_FMT(entity->name),
|
|
entity_world_pos.x,
|
|
entity_world_pos.y,
|
|
player_tile.x,
|
|
player_tile.y);
|
|
TELY_Render_Text(renderer, world_mouse_p, Dqn_V2_InitNx2(0.f, 1), label);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
extern "C" __declspec(dllexport)
|
|
void TELY_DLL_FrameUpdate(void *user_data)
|
|
{
|
|
TELY_Platform *platform = DQN_CAST(TELY_Platform *) user_data;
|
|
TELY_PlatformInput *input = &platform->input;
|
|
TELY_Assets *assets = &platform->assets;
|
|
TELY_Renderer *renderer = &platform->renderer;
|
|
FP_Game *game = DQN_CAST(FP_Game *) platform->user_data;
|
|
TELY_RFui *rfui = &game->rfui;
|
|
|
|
TELY_Render_ClearColourV3(renderer, TELY_COLOUR_BLACK_MIDNIGHT_V4.rgb);
|
|
TELY_Render_PushFont(renderer, game->jetbrains_mono_font);
|
|
|
|
TELY_RFui_FrameSetup(rfui, &platform->frame_arena);
|
|
TELY_RFui_PushFont(rfui, game->jetbrains_mono_font);
|
|
TELY_RFui_PushLabelColourV4(rfui, TELY_COLOUR_WHITE_PALE_GOLDENROD_V4);
|
|
|
|
// =============================================================================================
|
|
|
|
game->prev_clicked_entity = game->clicked_entity;
|
|
game->prev_hot_entity = game->hot_entity;
|
|
game->prev_active_entity = game->active_entity;
|
|
game->hot_entity = {};
|
|
game->active_entity = {};
|
|
Dqn_FArray_Clear(&game->parent_entity_stack);
|
|
Dqn_FArray_Add(&game->parent_entity_stack, game->root_entity->handle);
|
|
|
|
Dqn_M2x3 model_view = FP_Game_CameraModelViewM2x3(game->camera, platform);
|
|
TELY_Render_PushTransform(renderer, model_view);
|
|
Dqn_V2 world_mouse_p = Dqn_M2x3_MulV2(model_view, input->mouse_p);
|
|
|
|
// =============================================================================================
|
|
|
|
TELY_Audio *audio = &platform->audio;
|
|
if (audio->playback_size == 0) {
|
|
TELY_Audio_Play(audio, game->test_audio, 1.f /*volume*/);
|
|
}
|
|
|
|
// =============================================================================================
|
|
|
|
if (TELY_Platform_InputKeyWasDown(input->mouse_left) && TELY_Platform_InputKeyIsDown(input->mouse_left)) {
|
|
if (game->prev_active_entity.id)
|
|
game->active_entity = game->prev_active_entity;
|
|
} else {
|
|
for (FP_GameEntityIterator it = {}; FP_Game_DFSPreOrderWalkEntityTree(game, &it, game->root_entity); ) {
|
|
FP_GameEntity *entity = it.entity;
|
|
if (entity->local_hit_box_size.x <= 0 || entity->local_hit_box_size.y <= 0)
|
|
continue;
|
|
|
|
if ((entity->flags & FP_GameEntityFlag_Clickable) == 0)
|
|
continue;
|
|
|
|
Dqn_Rect world_hit_box = FP_Game_CalcEntityWorldHitBox(game, entity->handle);
|
|
if (!Dqn_Rect_ContainsPoint(world_hit_box, world_mouse_p))
|
|
continue;
|
|
|
|
game->hot_entity = entity->handle;
|
|
if (TELY_Platform_InputKeyIsPressed(input->mouse_left)) {
|
|
game->active_entity = entity->handle;
|
|
game->clicked_entity = entity->handle;
|
|
}
|
|
}
|
|
}
|
|
|
|
Dqn_f32 const PHYSICS_STEP = 1 / 60.f;
|
|
for (game->delta_s_accumulator += DQN_CAST(Dqn_f32)input->delta_s;
|
|
game->delta_s_accumulator > PHYSICS_STEP;
|
|
game->delta_s_accumulator -= PHYSICS_STEP) {
|
|
FP_Update(platform, game, renderer, input);
|
|
}
|
|
|
|
FP_Render(game, platform, renderer);
|
|
|
|
// NOTE: UI ====================================================================================
|
|
{
|
|
TELY_Render_PushTransform(renderer, Dqn_M2x3_Identity());
|
|
DQN_DEFER { TELY_Render_PopTransform(renderer); };
|
|
|
|
// NOTE: Info bar ==========================================================================
|
|
{
|
|
TELY_RFuiResult info_bar = TELY_RFui_Row(rfui, DQN_STRING8("Info Bar"));
|
|
info_bar.widget->semantic_position[TELY_RFuiAxis_X].kind = TELY_RFuiPositionKind_Absolute;
|
|
info_bar.widget->semantic_position[TELY_RFuiAxis_X].value = 10.f;
|
|
info_bar.widget->semantic_position[TELY_RFuiAxis_Y].kind = TELY_RFuiPositionKind_Absolute;
|
|
info_bar.widget->semantic_position[TELY_RFuiAxis_Y].value = 10.f;
|
|
|
|
TELY_RFui_PushParent(rfui, info_bar.widget);
|
|
DQN_DEFER { TELY_RFui_PopParent(rfui); };
|
|
|
|
Dqn_ThreadScratch scratch = Dqn_Thread_GetScratch(nullptr);
|
|
TELY_RFui_TextF(rfui, "TELY");
|
|
if (Dqn_String8_IsValid(platform->core.os_name)) {
|
|
TELY_RFui_TextF(rfui, " | %.*s", DQN_STRING_FMT(platform->core.os_name));
|
|
}
|
|
|
|
TELY_RFui_TextF(rfui,
|
|
" | %dx%d %.1fHz | TSC %.1f GHz",
|
|
platform->core.display.size.w,
|
|
platform->core.display.size.h,
|
|
platform->core.display.refresh_rate,
|
|
platform->core.tsc_per_second / 1'000'000'000.0);
|
|
|
|
if (platform->core.ram_mb)
|
|
TELY_RFui_TextF(rfui, " | RAM %.1fGB", platform->core.ram_mb / 1024.0);
|
|
|
|
TELY_RFui_TextF(rfui,
|
|
" | Work %04.1fms/f (%04.1f%%) | %05.1f FPS | Frame %'I64u | Timer %.1fs",
|
|
input->work_ms,
|
|
input->work_ms * 100.0 / input->delta_ms,
|
|
1000.0 / input->delta_ms,
|
|
input->frame_counter,
|
|
input->timer_s);
|
|
}
|
|
|
|
// NOTE: Profiler
|
|
{
|
|
TELY_RFuiResult profiler_layout = TELY_RFui_Column(rfui, DQN_STRING8("Profiler Bar"));
|
|
profiler_layout.widget->semantic_position[TELY_RFuiAxis_X].kind = TELY_RFuiPositionKind_Absolute;
|
|
profiler_layout.widget->semantic_position[TELY_RFuiAxis_X].value = 10.f;
|
|
profiler_layout.widget->semantic_position[TELY_RFuiAxis_Y].kind = TELY_RFuiPositionKind_Absolute;
|
|
profiler_layout.widget->semantic_position[TELY_RFuiAxis_Y].value = TELY_Asset_GetFont(assets, TELY_RFui_ActiveFont(rfui))->pixel_height * 1.5f;
|
|
|
|
TELY_RFui_PushParent(rfui, profiler_layout.widget);
|
|
DQN_DEFER { TELY_RFui_PopParent(rfui); };
|
|
|
|
Dqn_ProfilerAnchor *anchors = Dqn_Profiler_AnchorBuffer(Dqn_ProfilerAnchorBuffer_Back);
|
|
for (size_t anchor_index = 1; anchor_index < DQN_PROFILER_ANCHOR_BUFFER_SIZE; anchor_index++) {
|
|
Dqn_ProfilerAnchor const *anchor = anchors + anchor_index;
|
|
if (!anchor->hit_count)
|
|
continue;
|
|
|
|
uint64_t tsc_exclusive = anchor->tsc_exclusive;
|
|
uint64_t tsc_inclusive = anchor->tsc_inclusive;
|
|
Dqn_f64 tsc_exclusive_milliseconds = tsc_exclusive * 1000 / DQN_CAST(Dqn_f64)platform->core.tsc_per_second;
|
|
if (tsc_exclusive == tsc_inclusive) {
|
|
TELY_RFui_TextF(rfui,
|
|
"%.*s[%u]: %.1fms",
|
|
DQN_STRING_FMT(anchor->name),
|
|
anchor->hit_count,
|
|
tsc_exclusive_milliseconds);
|
|
} else {
|
|
Dqn_f64 tsc_inclusive_milliseconds = tsc_inclusive * 1000 / DQN_CAST(Dqn_f64)platform->core.tsc_per_second;
|
|
TELY_RFui_TextF(rfui,
|
|
"%.*s[%u]: %.1f/%.1fms",
|
|
DQN_STRING_FMT(anchor->name),
|
|
anchor->hit_count,
|
|
tsc_exclusive_milliseconds,
|
|
tsc_inclusive_milliseconds);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TELY_RFui_Flush(rfui, renderer, input, assets);
|
|
//TELY_Audio_MixPlaybackSamples(audio, assets);
|
|
}
|