doylet/Dengine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
3e2287e13a
Dengine/src/Debug.c

342 lines
11 KiB
C
Raw Normal View History

Update debug data architecture and methods
2016-07-09 10:46:04 +00:00
#include "Dengine/Debug.h"
Fix up include headers, try to reduce dependencies Ensure that all headers are self-sufficient instead of relying on included headers to include headers for execution.
2016-07-16 13:27:52 +00:00
#include "Dengine/Platform.h"
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
#include "Dengine/AssetManager.h"
Update debug data architecture and methods
2016-07-09 10:46:04 +00:00
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
DebugState GLOBAL_debug;
Update debug data architecture and methods
2016-07-09 10:46:04 +00:00
Mobs battle with hero, engine architect. changes Mobs battle in real-time with the hero when in range. Start encapsulating logic into entityStateSwitch() to organise entity properties changing between different states. Introduce basic concept of memory management in MemoryArena. Begin passing around a memory object to track memory usage and eventually delegate memory allocations through. Remove the old memory tracker in the debug object and incorporate into engine primarily. Add a debug console for logging information and events to the screen in a console-like fashion. Debug is now initialised after the game, this is so that you can pass the game's memory arena and font file to the debug services. Debug services now properly initialise debug element positions from this information and not through the update routine.
2016-07-19 11:19:26 +00:00
void debug_init(MemoryArena *arena, v2 windowSize, Font font)
Update debug data architecture and methods
2016-07-09 10:46:04 +00:00
{
Mobs battle with hero, engine architect. changes Mobs battle in real-time with the hero when in range. Start encapsulating logic into entityStateSwitch() to organise entity properties changing between different states. Introduce basic concept of memory management in MemoryArena. Begin passing around a memory object to track memory usage and eventually delegate memory allocations through. Remove the old memory tracker in the debug object and incorporate into engine primarily. Add a debug console for logging information and events to the screen in a console-like fashion. Debug is now initialised after the game, this is so that you can pass the game's memory arena and font file to the debug services. Debug services now properly initialise debug element positions from this information and not through the update routine.
2016-07-19 11:19:26 +00:00
GLOBAL_debug.font = font;
GLOBAL_debug.callCount = PLATFORM_MEM_ALLOC(arena, debugcallcount_num, i32);
GLOBAL_debug.stringLineGap = 1.1f * asset_getVFontSpacing(font.metrics);
Add memory allocation tracking data to debug state
2016-07-09 11:42:36 +00:00
Mobs battle with hero, engine architect. changes Mobs battle in real-time with the hero when in range. Start encapsulating logic into entityStateSwitch() to organise entity properties changing between different states. Introduce basic concept of memory management in MemoryArena. Begin passing around a memory object to track memory usage and eventually delegate memory allocations through. Remove the old memory tracker in the debug object and incorporate into engine primarily. Add a debug console for logging information and events to the screen in a console-like fashion. Debug is now initialised after the game, this is so that you can pass the game's memory arena and font file to the debug services. Debug services now properly initialise debug element positions from this information and not through the update routine.
2016-07-19 11:19:26 +00:00
/* Init debug string stack */
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
GLOBAL_debug.numDebugStrings = 0;
GLOBAL_debug.stringUpdateTimer = 0.0f;
GLOBAL_debug.stringUpdateRate = 0.15f;
Update debug data architecture and methods
2016-07-09 10:46:04 +00:00
Mobs battle with hero, engine architect. changes Mobs battle in real-time with the hero when in range. Start encapsulating logic into entityStateSwitch() to organise entity properties changing between different states. Introduce basic concept of memory management in MemoryArena. Begin passing around a memory object to track memory usage and eventually delegate memory allocations through. Remove the old memory tracker in the debug object and incorporate into engine primarily. Add a debug console for logging information and events to the screen in a console-like fashion. Debug is now initialised after the game, this is so that you can pass the game's memory arena and font file to the debug services. Debug services now properly initialise debug element positions from this information and not through the update routine.
2016-07-19 11:19:26 +00:00
GLOBAL_debug.initialStringP =
V2(0.0f, (windowSize.h - 1.8f * GLOBAL_debug.stringLineGap));
GLOBAL_debug.currStringP = GLOBAL_debug.initialStringP;
/* Init gui console */
i32 maxConsoleStrLen = ARRAY_COUNT(GLOBAL_debug.console[0]);
GLOBAL_debug.consoleIndex = 0;
// TODO(doyle): Font max size not entirely correct? using 1 * font.maxSize.w
// reveals around 4 characters ..
f32 consoleXPos = windowSize.x - (font.maxSize.w * 38);
f32 consoleYPos = windowSize.h - 1.8f * GLOBAL_debug.stringLineGap;
GLOBAL_debug.initialConsoleP = V2(consoleXPos, consoleYPos);
Update debug data architecture and methods
2016-07-09 10:46:04 +00:00
}
void debug_pushString(char *formatString, void *data, char *dataType)
{
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
if (GLOBAL_debug.stringUpdateTimer <= 0)
Update debug data architecture and methods
2016-07-09 10:46:04 +00:00
{
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
i32 numDebugStrings = GLOBAL_debug.numDebugStrings;
Update debug data architecture and methods
2016-07-09 10:46:04 +00:00
if (common_strcmp(dataType, "v2") == 0)
{
v2 val = *(CAST(v2 *) data);
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
snprintf(GLOBAL_debug.debugStrings[numDebugStrings],
ARRAY_COUNT(GLOBAL_debug.debugStrings[0]),
Update debug data architecture and methods
2016-07-09 10:46:04 +00:00
formatString, val.x, val.y);
}
else if (common_strcmp(dataType, "i32") == 0)
{
i32 val = *(CAST(i32 *) data);
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
snprintf(GLOBAL_debug.debugStrings[numDebugStrings],
ARRAY_COUNT(GLOBAL_debug.debugStrings[0]),
Update debug data architecture and methods
2016-07-09 10:46:04 +00:00
formatString, val);
}
Add distance to battle range metric in pixels
2016-07-15 16:34:44 +00:00
else if (common_strcmp(dataType, "f32") == 0)
{
f32 val = *(CAST(f32 *) data);
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
snprintf(GLOBAL_debug.debugStrings[numDebugStrings],
ARRAY_COUNT(GLOBAL_debug.debugStrings[0]),
Add distance to battle range metric in pixels
2016-07-15 16:34:44 +00:00
formatString, val);
}
Basic attack queue implemented for hero
2016-07-18 10:16:29 +00:00
else if (common_strcmp(dataType, "char") == 0)
{
Create notion of state switching for entities Encapsulate the process required to switch an entity from state to state using a state switching function. Add extra minor debug markers.
2016-07-19 05:19:08 +00:00
if (data)
{
char *val = CAST(char *) data;
Basic attack queue implemented for hero
2016-07-18 10:16:29 +00:00
Create notion of state switching for entities Encapsulate the process required to switch an entity from state to state using a state switching function. Add extra minor debug markers.
2016-07-19 05:19:08 +00:00
snprintf(GLOBAL_debug.debugStrings[numDebugStrings],
ARRAY_COUNT(GLOBAL_debug.debugStrings[0]),
formatString, val);
}
else
{
snprintf(GLOBAL_debug.debugStrings[numDebugStrings],
ARRAY_COUNT(GLOBAL_debug.debugStrings[0]),
formatString);
}
Basic attack queue implemented for hero
2016-07-18 10:16:29 +00:00
}
Create notion of state switching for entities Encapsulate the process required to switch an entity from state to state using a state switching function. Add extra minor debug markers.
2016-07-19 05:19:08 +00:00
Update debug data architecture and methods
2016-07-09 10:46:04 +00:00
else
{
ASSERT(INVALID_CODE_PATH);
}
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
GLOBAL_debug.numDebugStrings++;
Mobs battle with hero, engine architect. changes Mobs battle in real-time with the hero when in range. Start encapsulating logic into entityStateSwitch() to organise entity properties changing between different states. Introduce basic concept of memory management in MemoryArena. Begin passing around a memory object to track memory usage and eventually delegate memory allocations through. Remove the old memory tracker in the debug object and incorporate into engine primarily. Add a debug console for logging information and events to the screen in a console-like fashion. Debug is now initialised after the game, this is so that you can pass the game's memory arena and font file to the debug services. Debug services now properly initialise debug element positions from this information and not through the update routine.
2016-07-19 11:19:26 +00:00
ASSERT(GLOBAL_debug.numDebugStrings <
ARRAY_COUNT(GLOBAL_debug.debugStrings[0]));
Update debug data architecture and methods
2016-07-09 10:46:04 +00:00
}
}
Mobs battle with hero, engine architect. changes Mobs battle in real-time with the hero when in range. Start encapsulating logic into entityStateSwitch() to organise entity properties changing between different states. Introduce basic concept of memory management in MemoryArena. Begin passing around a memory object to track memory usage and eventually delegate memory allocations through. Remove the old memory tracker in the debug object and incorporate into engine primarily. Add a debug console for logging information and events to the screen in a console-like fashion. Debug is now initialised after the game, this is so that you can pass the game's memory arena and font file to the debug services. Debug services now properly initialise debug element positions from this information and not through the update routine.
2016-07-19 11:19:26 +00:00
INTERNAL void updateAndRenderDebugStack(Renderer *renderer, MemoryArena *arena,
f32 dt)
Update debug data architecture and methods
2016-07-09 10:46:04 +00:00
{
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
for (i32 i = 0; i < GLOBAL_debug.numDebugStrings; i++)
Update debug data architecture and methods
2016-07-09 10:46:04 +00:00
{
f32 rotate = 0;
v4 color = V4(0, 0, 0, 1);
Mobs battle with hero, engine architect. changes Mobs battle in real-time with the hero when in range. Start encapsulating logic into entityStateSwitch() to organise entity properties changing between different states. Introduce basic concept of memory management in MemoryArena. Begin passing around a memory object to track memory usage and eventually delegate memory allocations through. Remove the old memory tracker in the debug object and incorporate into engine primarily. Add a debug console for logging information and events to the screen in a console-like fashion. Debug is now initialised after the game, this is so that you can pass the game's memory arena and font file to the debug services. Debug services now properly initialise debug element positions from this information and not through the update routine.
2016-07-19 11:19:26 +00:00
renderer_staticString(renderer, arena, &GLOBAL_debug.font,
GLOBAL_debug.debugStrings[i],
GLOBAL_debug.currStringP, rotate, color);
GLOBAL_debug.currStringP.y -= (0.9f * GLOBAL_debug.stringLineGap);
Update debug data architecture and methods
2016-07-09 10:46:04 +00:00
}
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
if (GLOBAL_debug.stringUpdateTimer <= 0)
Update debug data architecture and methods
2016-07-09 10:46:04 +00:00
{
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
GLOBAL_debug.stringUpdateTimer =
GLOBAL_debug.stringUpdateRate;
Update debug data architecture and methods
2016-07-09 10:46:04 +00:00
}
else
{
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
GLOBAL_debug.stringUpdateTimer -= dt;
if (GLOBAL_debug.stringUpdateTimer <= 0)
Update debug data architecture and methods
2016-07-09 10:46:04 +00:00
{
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
GLOBAL_debug.numDebugStrings = 0;
Update debug data architecture and methods
2016-07-09 10:46:04 +00:00
}
}
Mobs battle with hero, engine architect. changes Mobs battle in real-time with the hero when in range. Start encapsulating logic into entityStateSwitch() to organise entity properties changing between different states. Introduce basic concept of memory management in MemoryArena. Begin passing around a memory object to track memory usage and eventually delegate memory allocations through. Remove the old memory tracker in the debug object and incorporate into engine primarily. Add a debug console for logging information and events to the screen in a console-like fashion. Debug is now initialised after the game, this is so that you can pass the game's memory arena and font file to the debug services. Debug services now properly initialise debug element positions from this information and not through the update routine.
2016-07-19 11:19:26 +00:00
GLOBAL_debug.currStringP = GLOBAL_debug.initialStringP;
}
INTERNAL void renderConsole(Renderer *renderer, MemoryArena *arena)
{
i32 maxConsoleLines = ARRAY_COUNT(GLOBAL_debug.console);
v2 consoleStrP = GLOBAL_debug.initialConsoleP;
for (i32 i = 0; i < maxConsoleLines; i++)
{
f32 rotate = 0;
v4 color = V4(0, 0, 0, 1);
renderer_staticString(renderer, arena, &GLOBAL_debug.font,
GLOBAL_debug.console[i], consoleStrP,
rotate, color);
consoleStrP.y -= (0.9f * GLOBAL_debug.stringLineGap);
}
Update debug data architecture and methods
2016-07-09 10:46:04 +00:00
}
Add function call counting to debug infrastructure
2016-07-09 10:59:54 +00:00
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
void debug_drawUi(GameState *state, f32 dt)
{
AssetManager *assetManager = &state->assetManager;
Renderer *renderer = &state->renderer;
World *const world = &state->world[state->currWorldIndex];
Entity *hero = &world->entities[world->heroIndex];
// TODO(doyle): Dumb copy function from game so we don't expose api
v4 cameraBounds = math_getRect(world->cameraPos, renderer->size);
if (cameraBounds.x <= world->bounds.x)
{
cameraBounds.x = world->bounds.x;
cameraBounds.z = cameraBounds.x + renderer->size.w;
}
if (cameraBounds.y >= world->bounds.y) cameraBounds.y = world->bounds.y;
if (cameraBounds.z >= world->bounds.z)
{
cameraBounds.z = world->bounds.z;
cameraBounds.x = cameraBounds.z - renderer->size.w;
}
if (cameraBounds.w <= world->bounds.w) cameraBounds.w = world->bounds.w;
#if 0
Texture *emptyTex = asset_getTexture(assetManager, texlist_empty);
v2 heroCenter = v2_add(hero->pos, v2_scale(hero->hitboxSize, 0.5f));
RenderTex renderTex = {emptyTex, V4(0, 1, 1, 0)};
renderer_rect(&state->renderer, cameraBounds, heroCenter,
V2(distance, 5.0f), 0, renderTex, V4(1, 0, 0, 0.25f));
#endif
Mobs battle with hero, engine architect. changes Mobs battle in real-time with the hero when in range. Start encapsulating logic into entityStateSwitch() to organise entity properties changing between different states. Introduce basic concept of memory management in MemoryArena. Begin passing around a memory object to track memory usage and eventually delegate memory allocations through. Remove the old memory tracker in the debug object and incorporate into engine primarily. Add a debug console for logging information and events to the screen in a console-like fashion. Debug is now initialised after the game, this is so that you can pass the game's memory arena and font file to the debug services. Debug services now properly initialise debug element positions from this information and not through the update routine.
2016-07-19 11:19:26 +00:00
Font *font = &GLOBAL_debug.font;
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
if (world->numEntitiesInBattle > 0)
{
v4 color = V4(1.0f, 0, 0, 1);
char *battleStr = "IN-BATTLE RANGE";
f32 strLenInPixels =
CAST(f32)(font->maxSize.w * common_strlen(battleStr));
v2 strPos = V2((renderer->size.w * 0.5f) - (strLenInPixels * 0.5f),
renderer->size.h - 300.0f);
Mobs battle with hero, engine architect. changes Mobs battle in real-time with the hero when in range. Start encapsulating logic into entityStateSwitch() to organise entity properties changing between different states. Introduce basic concept of memory management in MemoryArena. Begin passing around a memory object to track memory usage and eventually delegate memory allocations through. Remove the old memory tracker in the debug object and incorporate into engine primarily. Add a debug console for logging information and events to the screen in a console-like fashion. Debug is now initialised after the game, this is so that you can pass the game's memory arena and font file to the debug services. Debug services now properly initialise debug element positions from this information and not through the update routine.
2016-07-19 11:19:26 +00:00
renderer_staticString(&state->renderer, &state->arena, font, battleStr,
strPos, 0, color);
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
}
Create notion of state switching for entities Encapsulate the process required to switch an entity from state to state using a state switching function. Add extra minor debug markers.
2016-07-19 05:19:08 +00:00
for (i32 i = 0; i < world->maxEntities; i++)
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
{
Create notion of state switching for entities Encapsulate the process required to switch an entity from state to state using a state switching function. Add extra minor debug markers.
2016-07-19 05:19:08 +00:00
Entity *const entity = &world->entities[i];
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
/* Render debug markers on entities */
v4 color = V4(1, 1, 1, 1);
char *debugString = NULL;
switch (entity->type)
{
case entitytype_mob:
color = V4(1, 0, 0, 1);
debugString = "MOB";
break;
case entitytype_hero:
color = V4(0, 0, 1.0f, 1);
debugString = "HERO";
break;
case entitytype_npc:
color = V4(0, 1.0f, 0, 1);
debugString = "NPC";
break;
default:
break;
}
if (debugString)
{
v2 strPos = v2_add(entity->pos, entity->hitboxSize);
i32 indexOfLowerAInMetrics = 'a' - CAST(i32) font->codepointRange.x;
strPos.y += font->charMetrics[indexOfLowerAInMetrics].offset.y;
Mobs battle with hero, engine architect. changes Mobs battle in real-time with the hero when in range. Start encapsulating logic into entityStateSwitch() to organise entity properties changing between different states. Introduce basic concept of memory management in MemoryArena. Begin passing around a memory object to track memory usage and eventually delegate memory allocations through. Remove the old memory tracker in the debug object and incorporate into engine primarily. Add a debug console for logging information and events to the screen in a console-like fashion. Debug is now initialised after the game, this is so that you can pass the game's memory arena and font file to the debug services. Debug services now properly initialise debug element positions from this information and not through the update routine.
2016-07-19 11:19:26 +00:00
renderer_string(&state->renderer, &state->arena, cameraBounds, font,
debugString, strPos, 0, color);
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
f32 stringLineGap = 1.1f * asset_getVFontSpacing(font->metrics);
strPos.y -= GLOBAL_debug.stringLineGap;
char entityPosStr[128];
snprintf(entityPosStr, ARRAY_COUNT(entityPosStr), "%06.2f, %06.2f",
entity->pos.x, entity->pos.y);
Mobs battle with hero, engine architect. changes Mobs battle in real-time with the hero when in range. Start encapsulating logic into entityStateSwitch() to organise entity properties changing between different states. Introduce basic concept of memory management in MemoryArena. Begin passing around a memory object to track memory usage and eventually delegate memory allocations through. Remove the old memory tracker in the debug object and incorporate into engine primarily. Add a debug console for logging information and events to the screen in a console-like fashion. Debug is now initialised after the game, this is so that you can pass the game's memory arena and font file to the debug services. Debug services now properly initialise debug element positions from this information and not through the update routine.
2016-07-19 11:19:26 +00:00
renderer_string(&state->renderer, &state->arena, cameraBounds, font,
entityPosStr, strPos, 0, color);
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
strPos.y -= GLOBAL_debug.stringLineGap;
char entityIDStr[32];
Create notion of state switching for entities Encapsulate the process required to switch an entity from state to state using a state switching function. Add extra minor debug markers.
2016-07-19 05:19:08 +00:00
snprintf(entityIDStr, ARRAY_COUNT(entityIDStr), "ID: %4d/%d", entity->id,
world->uniqueIdAccumulator-1);
Mobs battle with hero, engine architect. changes Mobs battle in real-time with the hero when in range. Start encapsulating logic into entityStateSwitch() to organise entity properties changing between different states. Introduce basic concept of memory management in MemoryArena. Begin passing around a memory object to track memory usage and eventually delegate memory allocations through. Remove the old memory tracker in the debug object and incorporate into engine primarily. Add a debug console for logging information and events to the screen in a console-like fashion. Debug is now initialised after the game, this is so that you can pass the game's memory arena and font file to the debug services. Debug services now properly initialise debug element positions from this information and not through the update routine.
2016-07-19 11:19:26 +00:00
renderer_string(&state->renderer, &state->arena, cameraBounds, font,
entityIDStr, strPos, 0, color);
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
if (entity->stats)
{
strPos.y -= GLOBAL_debug.stringLineGap;
char entityHealth[32];
snprintf(entityHealth, ARRAY_COUNT(entityHealth), "HP: %3.0f/%3.0f",
entity->stats->health, entity->stats->maxHealth);
Mobs battle with hero, engine architect. changes Mobs battle in real-time with the hero when in range. Start encapsulating logic into entityStateSwitch() to organise entity properties changing between different states. Introduce basic concept of memory management in MemoryArena. Begin passing around a memory object to track memory usage and eventually delegate memory allocations through. Remove the old memory tracker in the debug object and incorporate into engine primarily. Add a debug console for logging information and events to the screen in a console-like fashion. Debug is now initialised after the game, this is so that you can pass the game's memory arena and font file to the debug services. Debug services now properly initialise debug element positions from this information and not through the update routine.
2016-07-19 11:19:26 +00:00
renderer_string(&state->renderer, &state->arena, cameraBounds,
font, entityHealth, strPos, 0, color);
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
strPos.y -= GLOBAL_debug.stringLineGap;
char entityTimer[32];
snprintf(entityTimer, ARRAY_COUNT(entityTimer), "ATB: %3.0f/%3.0f",
entity->stats->actionTimer, entity->stats->actionRate);
Mobs battle with hero, engine architect. changes Mobs battle in real-time with the hero when in range. Start encapsulating logic into entityStateSwitch() to organise entity properties changing between different states. Introduce basic concept of memory management in MemoryArena. Begin passing around a memory object to track memory usage and eventually delegate memory allocations through. Remove the old memory tracker in the debug object and incorporate into engine primarily. Add a debug console for logging information and events to the screen in a console-like fashion. Debug is now initialised after the game, this is so that you can pass the game's memory arena and font file to the debug services. Debug services now properly initialise debug element positions from this information and not through the update routine.
2016-07-19 11:19:26 +00:00
renderer_string(&state->renderer, &state->arena, cameraBounds,
font, entityTimer, strPos, 0, color);
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
}
Create notion of state switching for entities Encapsulate the process required to switch an entity from state to state using a state switching function. Add extra minor debug markers.
2016-07-19 05:19:08 +00:00
strPos.y -= GLOBAL_debug.stringLineGap;
char *entityStateStr = debug_entitystate_string(entity->state);
Mobs battle with hero, engine architect. changes Mobs battle in real-time with the hero when in range. Start encapsulating logic into entityStateSwitch() to organise entity properties changing between different states. Introduce basic concept of memory management in MemoryArena. Begin passing around a memory object to track memory usage and eventually delegate memory allocations through. Remove the old memory tracker in the debug object and incorporate into engine primarily. Add a debug console for logging information and events to the screen in a console-like fashion. Debug is now initialised after the game, this is so that you can pass the game's memory arena and font file to the debug services. Debug services now properly initialise debug element positions from this information and not through the update routine.
2016-07-19 11:19:26 +00:00
renderer_string(&state->renderer, &state->arena, cameraBounds, font,
Create notion of state switching for entities Encapsulate the process required to switch an entity from state to state using a state switching function. Add extra minor debug markers.
2016-07-19 05:19:08 +00:00
entityStateStr, strPos, 0, color);
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
}
}
/* Render debug info stack */
Create notion of state switching for entities Encapsulate the process required to switch an entity from state to state using a state switching function. Add extra minor debug markers.
2016-07-19 05:19:08 +00:00
DEBUG_PUSH_STRING("== Hero Properties == ");
DEBUG_PUSH_VAR("Hero Pos: %06.2f, %06.2f", hero->pos, "v2");
DEBUG_PUSH_VAR("Hero dPos: %06.2f, %06.2f", hero->dPos, "v2");
DEBUG_PUSH_VAR("Hero Busy Duration: %05.3f", hero->stats->busyDuration, "f32");
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
char *heroStateString = debug_entitystate_string(hero->state);
Create notion of state switching for entities Encapsulate the process required to switch an entity from state to state using a state switching function. Add extra minor debug markers.
2016-07-19 05:19:08 +00:00
DEBUG_PUSH_VAR("Hero State: %s", *heroStateString, "char");
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
char *heroQueuedAttackStr =
debug_entityattack_string(hero->stats->queuedAttack);
Create notion of state switching for entities Encapsulate the process required to switch an entity from state to state using a state switching function. Add extra minor debug markers.
2016-07-19 05:19:08 +00:00
DEBUG_PUSH_VAR("Hero QueuedAttack: %s", *heroQueuedAttackStr, "char");
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
Create notion of state switching for entities Encapsulate the process required to switch an entity from state to state using a state switching function. Add extra minor debug markers.
2016-07-19 05:19:08 +00:00
DEBUG_PUSH_STRING("== State Properties == ");
DEBUG_PUSH_VAR("FreeEntityIndex: %d", world->freeEntityIndex, "i32");
DEBUG_PUSH_VAR("glDrawArray Calls: %d",
GLOBAL_debug.callCount[debugcallcount_drawArrays], "i32");
Mobs battle with hero, engine architect. changes Mobs battle in real-time with the hero when in range. Start encapsulating logic into entityStateSwitch() to organise entity properties changing between different states. Introduce basic concept of memory management in MemoryArena. Begin passing around a memory object to track memory usage and eventually delegate memory allocations through. Remove the old memory tracker in the debug object and incorporate into engine primarily. Add a debug console for logging information and events to the screen in a console-like fashion. Debug is now initialised after the game, this is so that you can pass the game's memory arena and font file to the debug services. Debug services now properly initialise debug element positions from this information and not through the update routine.
2016-07-19 11:19:26 +00:00
i32 debug_kbAllocated = state->arena.bytesAllocated / 1024;
Create notion of state switching for entities Encapsulate the process required to switch an entity from state to state using a state switching function. Add extra minor debug markers.
2016-07-19 05:19:08 +00:00
DEBUG_PUSH_VAR("TotalMemoryAllocated: %dkb", debug_kbAllocated, "i32");
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
Create notion of state switching for entities Encapsulate the process required to switch an entity from state to state using a state switching function. Add extra minor debug markers.
2016-07-19 05:19:08 +00:00
DEBUG_PUSH_STRING("== EntityIDs in Battle List == ");
DEBUG_PUSH_VAR("NumEntitiesInBattle: %d", world->numEntitiesInBattle,
"i32");
if (world->numEntitiesInBattle > 0)
{
for (i32 i = 0; i < world->maxEntities; i++)
{
if (world->entityIdInBattle[i])
DEBUG_PUSH_VAR("Entity ID: %d", i, "i32");
}
}
else
{
DEBUG_PUSH_STRING("-none-");
}
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
Mobs battle with hero, engine architect. changes Mobs battle in real-time with the hero when in range. Start encapsulating logic into entityStateSwitch() to organise entity properties changing between different states. Introduce basic concept of memory management in MemoryArena. Begin passing around a memory object to track memory usage and eventually delegate memory allocations through. Remove the old memory tracker in the debug object and incorporate into engine primarily. Add a debug console for logging information and events to the screen in a console-like fashion. Debug is now initialised after the game, this is so that you can pass the game's memory arena and font file to the debug services. Debug services now properly initialise debug element positions from this information and not through the update routine.
2016-07-19 11:19:26 +00:00
updateAndRenderDebugStack(&state->renderer, &state->arena, dt);
renderConsole(&state->renderer, &state->arena);
Implement battle time bar attacking within range The main debug drawing elements have been moved to debug.c to avoid cluttering up the main game file. The downside is that thus far the debug values only track values post-update. We have a notion of begin attack and end attack to allow code to drive the animation system and apply effects after an attack animation has completed.
2016-07-18 12:02:47 +00:00
debug_clearCallCounter();
}
Mobs battle with hero, engine architect. changes Mobs battle in real-time with the hero when in range. Start encapsulating logic into entityStateSwitch() to organise entity properties changing between different states. Introduce basic concept of memory management in MemoryArena. Begin passing around a memory object to track memory usage and eventually delegate memory allocations through. Remove the old memory tracker in the debug object and incorporate into engine primarily. Add a debug console for logging information and events to the screen in a console-like fashion. Debug is now initialised after the game, this is so that you can pass the game's memory arena and font file to the debug services. Debug services now properly initialise debug element positions from this information and not through the update routine.
2016-07-19 11:19:26 +00:00
void debug_consoleLog(char *string, char *file, int lineNum)
{
i32 maxConsoleStrLen = ARRAY_COUNT(GLOBAL_debug.console[0]);
i32 strIndex = 0;
i32 fileStrLen = common_strlen(file);
for (i32 count = 0; strIndex < maxConsoleStrLen; strIndex++, count++)
{
if (fileStrLen <= count) break;
GLOBAL_debug.console[GLOBAL_debug.consoleIndex][strIndex] = file[count];
}
if (strIndex < maxConsoleStrLen)
GLOBAL_debug.console[GLOBAL_debug.consoleIndex][strIndex++] = ':';
char line[12] = {0};
common_itoa(lineNum, line, ARRAY_COUNT(line));
i32 lineStrLen = common_strlen(line);
for (i32 count = 0; strIndex < maxConsoleStrLen; strIndex++, count++)
{
if (lineStrLen <= count) break;
GLOBAL_debug.console[GLOBAL_debug.consoleIndex][strIndex] = line[count];
}
if (strIndex < maxConsoleStrLen)
GLOBAL_debug.console[GLOBAL_debug.consoleIndex][strIndex++] = ':';
i32 stringStrLen = common_strlen(string);
for (i32 count = 0; strIndex < maxConsoleStrLen; strIndex++, count++)
{
if (stringStrLen <= count) break;
GLOBAL_debug.console[GLOBAL_debug.consoleIndex][strIndex] = string[count];
}
if (strIndex >= maxConsoleStrLen)
{
GLOBAL_debug.console[GLOBAL_debug.consoleIndex][maxConsoleStrLen-4] = '.';
GLOBAL_debug.console[GLOBAL_debug.consoleIndex][maxConsoleStrLen-3] = '.';
GLOBAL_debug.console[GLOBAL_debug.consoleIndex][maxConsoleStrLen-2] = '.';
GLOBAL_debug.console[GLOBAL_debug.consoleIndex][maxConsoleStrLen-1] = 0;
}
i32 maxConsoleLines = ARRAY_COUNT(GLOBAL_debug.console);
GLOBAL_debug.consoleIndex++;
if (GLOBAL_debug.consoleIndex >= maxConsoleLines)
GLOBAL_debug.consoleIndex = 0;
}
Reference in New Issue Copy Permalink