void print_threadConfig(void)
{
t_threadConfigList threadConfigList;
common_memset(&threadConfigList, 0x00, sizeof(t_threadConfigList));
config_getThreadConifg("inputfile/threadConfig.xml",&threadConfigList);
int i = 0;
fprintf(stdout, "count=%d\n", threadConfigList.threadCount);
for( i=0; i < threadConfigList.threadCount; i++) {
fprintf(stdout, "threadConfig[%d].id=%d\n", i, threadConfigList.list[i].id);
fprintf(stdout, "threadConfig[%d].parentId=%d\n", i, threadConfigList.list[i].parentId);
}
common_free(threadConfigList.list);
}
void print_threadAction(void)
{
t_threadActionListInfo actionListInfo;
common_memset(&actionListInfo, 0x00, sizeof(t_threadActionListInfo));
#if 0
void* handle = dlopen(NULL, RTLD_LAZY);
#endif
config_getThreadAction("inputfile/threadAction.xml", &actionListInfo);
int threadCount = 0;
#if 0
fprintf(stdout, "threadCount=%d\n", actionListInfo.threadCount);
for( threadCount = 0; threadCount < actionListInfo.threadCount; threadCount++) {
t_threadActionList* actionList = &actionListInfo.list[threadCount];
fprintf(stdout, "threadID=%d arrayCount=%d\n", actionList->threadId, actionList->arrayCount);
int arrayIdx = 0;
for( arrayIdx = 0; arrayIdx < actionList->arrayCount; arrayIdx++) {
t_threadAction* action = &actionList->array[arrayIdx];
fprintf(stdout, "name=%s\n", action->name);
fprintf(stdout, "%p\n", dlsym(handle, action->name));
}
}
#endif
threadCount = 0;
for( threadCount = 0; threadCount < actionListInfo.threadCount; threadCount++) {
t_threadActionList* actionList = &actionListInfo.list[threadCount];
common_free(actionList->array);
}
common_free(actionListInfo.list);
#if 0
dlclose(handle);
#endif
}
INTERNAL void gameUpdate(GameState *state, Memory *memory, f32 dt)
{
GameWorldState *world =
GET_STATE_DATA(state, &state->persistentArena, GameWorldState);
if (!common_isSet(world->flags, gameworldstateflags_init))
{
#ifdef DENGINE_DEBUG
{
u8 *data = (u8 *)world;
for (i32 i = 0; i < sizeof(GameWorldState); i++)
ASSERT(data[i] == 0);
}
#endif
world->pixelsPerMeter = 70.0f;
MemoryIndex entityArenaSize =
(MemoryIndex)((f32)memory->transientSize * 0.5f);
u8 *arenaBase = state->transientArena.base + state->transientArena.size;
memory_arenaInit(&world->entityArena, arenaBase, entityArenaSize);
world->camera.min = V2(0, 0);
world->camera.max = state->renderer.size;
world->size = state->renderer.size;
world->entityListSize = 1024;
world->entityList = MEMORY_PUSH_ARRAY(&world->entityArena,
world->entityListSize, Entity);
{ // Init null entity
Entity *nullEntity = &world->entityList[world->entityIndex++];
nullEntity->id = world->entityIdCounter++;
}
{ // Init asteroid entities
world->numAsteroids = 15;
}
{ // Init audio renderer
world->numAudioRenderers = 8;
world->audioRenderer = MEMORY_PUSH_ARRAY(
&world->entityArena, world->numAudioRenderers, AudioRenderer);
}
{ // Global Collision Rules
setCollisionRule(world, entitytype_ship, entitytype_asteroid_small,
TRUE);
setCollisionRule(world, entitytype_ship, entitytype_asteroid_medium,
TRUE);
setCollisionRule(world, entitytype_ship, entitytype_asteroid_large,
TRUE);
setCollisionRule(world, entitytype_bullet,
entitytype_asteroid_small, TRUE);
setCollisionRule(world, entitytype_bullet,
entitytype_asteroid_medium, TRUE);
setCollisionRule(world, entitytype_bullet,
entitytype_asteroid_large, TRUE);
}
world->numStarP = 100;
world->starPList =
MEMORY_PUSH_ARRAY(&world->entityArena, world->numStarP, v2);
world->starMinOpacity = 0.25f;
for (i32 i = 0; i < world->numStarP; i++)
{
i32 randX = rand() % (i32)world->size.x;
i32 randY = rand() % (i32)world->size.y;
world->starPList[i] = V2i(randX, randY);
}
world->flags |= gameworldstateflags_init;
world->scoreMultiplier = 5;
world->scoreMultiplierBarTimer = 0.0f;
world->scoreMultiplierBarThresholdInS = 2.0f;
}
if (common_isSet(world->flags, gameworldstateflags_level_started))
{
Font *arial40 = asset_fontGet(&state->assetManager, "Arial", 40);
Renderer *renderer = &state->renderer;
/* Render scores onto screen */
v2 stringP =
V2((renderer->size.w * 0.5f), renderer->size.h - arial40->size);
char gamePointsString[COMMON_ITOA_MAX_BUFFER_32BIT] = {0};
common_itoa(world->score, gamePointsString,
ARRAY_COUNT(gamePointsString));
renderer_stringFixedCentered(renderer, &state->transientArena, arial40,
gamePointsString, stringP, V2(0, 0), 0,
V4(1.0f, 1.0f, 1.0f, 1.0f), 1, 0);
/* Render multiplier accumulator bar onto screen */
v2 stringDim = asset_fontStringDimInPixels(arial40, gamePointsString);
v2 multiplierOutlineSize =
V2(renderer->size.w * 0.5f, stringDim.h * 0.25f);
v2 multiplierOutlineP = V2(renderer->size.w * 0.5f, stringP.h);
multiplierOutlineP.x -= (multiplierOutlineSize.w * 0.5f);
multiplierOutlineP.y -= stringDim.h * 1.5f;
renderer_rectFixedOutline(
renderer, multiplierOutlineP, multiplierOutlineSize, V2(0, 0), 2, 0,
NULL, V4(0.2f, 0.3f, 0.8f, 1.0f), 2, renderflag_no_texture);
f32 progressNormalised = world->scoreMultiplierBarTimer /
world->scoreMultiplierBarThresholdInS;
renderer_rectFixed(renderer, multiplierOutlineP,
V2(multiplierOutlineSize.w * progressNormalised,
multiplierOutlineSize.h),
V2(0, 0), 0, NULL, V4(0.2f, 0.3f, 0.8f, 1.0f), 1,
renderflag_no_texture);
/* Render multiplier counter hud onto screen */
v2 multiplierHudP = V2(0, 0.05f * renderer->size.h);
v2 multiplierHudSize =
V2((arial40->maxSize.w * 3.5f), arial40->fontHeight * 1.2f);
renderer_rectFixed(renderer, multiplierHudP, multiplierHudSize,
V2(0, 0), 0, NULL, V4(1, 1, 1, 0.1f), 2,
renderflag_no_texture);
/* Render multiplier counter string to hud */
char multiplierToString[COMMON_ITOA_MAX_BUFFER_32BIT + 1] = {0};
common_itoa(world->scoreMultiplier, multiplierToString + 1,
ARRAY_COUNT(multiplierToString) - 1);
multiplierToString[0] = 'x';
v2 multiplierToStringP = multiplierHudP;
multiplierToStringP =
v2_add(multiplierToStringP, v2_scale(multiplierHudSize, 0.5f));
renderer_stringFixedCentered(
renderer, &state->transientArena, arial40, multiplierToString,
multiplierToStringP, V2(0, 0), 0, V4(1.0f, 1.0f, 1.0f, 1.0f), 3, 0);
/* Process multiplier bar updates */
if (!common_isSet(world->flags, gameworldstateflags_player_lost))
{
f32 barTimerPenalty = 1.0f;
if (world->timeSinceLastShot < 1.5f)
{
barTimerPenalty = 0.1f;
}
world->scoreMultiplierBarTimer += (barTimerPenalty * dt);
world->timeSinceLastShot += dt;
if (world->scoreMultiplierBarTimer >
world->scoreMultiplierBarThresholdInS)
{
world->scoreMultiplierBarTimer = 0;
world->scoreMultiplier++;
if (world->scoreMultiplier > 9999)
world->scoreMultiplier = 9999;
}
}
}
if (common_isSet(world->flags, gameworldstateflags_player_lost))
{
Font *arial40 = asset_fontGet(&state->assetManager, "Arial", 40);
char *gameOver = "Game Over";
v2 gameOverP = v2_scale(state->renderer.size, 0.5f);
renderer_stringFixedCentered(
&state->renderer, &state->transientArena, arial40, "Game Over",
gameOverP, V2(0, 0), 0, V4(1, 1, 1, 1), 0, 0);
v2 gameOverSize = asset_fontStringDimInPixels(arial40, gameOver);
v2 replayP = V2(gameOverP.x, gameOverP.y - (gameOverSize.h * 1.2f));
renderer_stringFixedCentered(
&state->renderer, &state->transientArena, arial40,
"Press enter to play again or backspace to return to menu", replayP,
V2(0, 0), 0, V4(1, 1, 1, 1), 0, 0);
if (platform_queryKey(&state->input.keys[keycode_enter],
readkeytype_one_shot, 0.0f))
{
// TODO(doyle): Extract score init default values to some game
// definitions file
world->score = 0;
world->scoreMultiplier = 5;
world->scoreMultiplierBarTimer = 0.0f;
world->scoreMultiplierBarThresholdInS = 2.0f;
addPlayer(world);
world->flags ^= gameworldstateflags_player_lost;
}
else if (platform_queryKey(&state->input.keys[keycode_backspace],
readkeytype_one_shot, 0.0f))
{
common_memset((u8 *)world, 0, sizeof(*world));
state->currState = appstate_StartMenuState;
return;
}
}
for (u32 i = world->asteroidCounter; i < world->numAsteroids; i++)
addAsteroid(world, (rand() % asteroidsize_count));
Radians starRotation = DEGREES_TO_RADIANS(45.0f);
v2 starSize = V2(2, 2);
ASSERT(world->starMinOpacity >= 0.0f && world->starMinOpacity <= 1.0f);
f32 opacityFadeRateInS = 0.5f;
if (world->starFadeAway)
{
opacityFadeRateInS *= -1.0f;
}
if (world->starOpacity > 1.0f)
{
world->starOpacity = 1.0f;
world->starFadeAway = TRUE;
}
else if (world->starOpacity < world->starMinOpacity)
{
world->starOpacity = world->starMinOpacity;
world->starFadeAway = FALSE;
}
world->starOpacity += (opacityFadeRateInS * dt);
DEBUG_PUSH_VAR("Star Opacity: %5.2f", world->starOpacity, "f32");
for (i32 i = 0; i < world->numStarP; i++)
{
world->starPList[i] = v2_add(world->starPList[i], V2(4.0f * dt, 0));
world->starPList[i] = wrapPAroundBounds(
world->starPList[i], math_rectCreate(V2(0, 0), world->size));
renderer_rect(&state->renderer, world->camera, world->starPList[i],
starSize, V2(0, 0), starRotation, NULL,
V4(0.8f, 0.8f, 0.8f, world->starOpacity), 0,
renderflag_no_texture | renderflag_wireframe);
}
#ifdef DENGINE_DEBUG
if (platform_queryKey(&state->input.keys[keycode_left_square_bracket],
readkeytype_repeat, 0.2f))
{
addAsteroid(world, (rand() % asteroidsize_count));
}
#endif
ASSERT(world->entityList[0].id == NULL_ENTITY_ID);
for (i32 i = 1; i < world->entityIndex; i++)
{
Entity *entity = &world->entityList[i];
ASSERT(entity->type != entitytype_invalid);
v2 pivotPoint = {0};
f32 ddPSpeedInMs = 0;
v2 ddP = {0};
if (entity->type == entitytype_ship)
{
if (platform_queryKey(&state->input.keys[keycode_up],
readkeytype_repeat, 0.0f))
{
// TODO(doyle): Renderer creates upfacing triangles by default,
// but we need to offset rotation so that our base "0 degrees"
// is right facing for trig to work
Radians rotation =
DEGREES_TO_RADIANS((entity->rotation + 90.0f));
v2 direction = V2(math_cosf(rotation), math_sinf(rotation));
ddP = direction;
AudioVorbis *thrust =
asset_vorbisGet(&state->assetManager, "thrust");
AudioRenderer *audioRenderer =
getFreeAudioRenderer(world, thrust, 3);
if (audioRenderer)
{
audio_vorbisPlay(&state->transientArena,
&state->audioManager, audioRenderer,
thrust, 1);
}
}
if (platform_queryKey(&state->input.keys[keycode_space],
readkeytype_one_shot, KEY_DELAY_NONE))
{
addBullet(world, entity);
if (world->timeSinceLastShot >= 0)
{
world->timeSinceLastShot = 0;
f32 multiplierPenalty = -2.0f;
world->timeSinceLastShot += multiplierPenalty;
}
AudioVorbis *fire =
asset_vorbisGet(&state->assetManager, "fire");
AudioRenderer *audioRenderer =
getFreeAudioRenderer(world, fire, 2);
if (audioRenderer)
{
// TODO(doyle): Atm transient arena is not used, this is
// just to fill out the arguments
audio_vorbisPlay(&state->transientArena,
&state->audioManager, audioRenderer, fire,
1);
}
}
Degrees rotationsPerSecond = 180.0f;
if (platform_queryKey(&state->input.keys[keycode_left],
readkeytype_repeat, 0.0f))
{
entity->rotation += (rotationsPerSecond)*dt;
}
if (platform_queryKey(&state->input.keys[keycode_right],
readkeytype_repeat, 0.0f))
{
entity->rotation -= (rotationsPerSecond)*dt;
}
entity->rotation = (f32)((i32)entity->rotation);
ddPSpeedInMs = 25;
DEBUG_PUSH_VAR("Pos: %5.2f, %5.2f", entity->pos, "v2");
DEBUG_PUSH_VAR("Velocity: %5.2f, %5.2f", entity->dP, "v2");
DEBUG_PUSH_VAR("Rotation: %5.2f", entity->rotation, "f32");
DEBUG_PUSH_VAR("TimeSinceLastShot: %5.2f", world->timeSinceLastShot,
"f32");
renderer_rect(&state->renderer, world->camera, entity->pos,
V2(5, 5), V2(0, 0),
DEGREES_TO_RADIANS(entity->rotation), NULL,
V4(1.0f, 1.0f, 1.0f, 1.0f), 0, renderflag_no_texture);
}
else if (entity->type >= entitytype_asteroid_small &&
entity->type <= entitytype_asteroid_large)
{
i32 randValue = rand();
// NOTE(doyle): If it is a new asteroid with no dp set, we need to
// set a initial dp for it to move from.
v2 localDp = {0};
if ((i32)entity->dP.x == 0 && (i32)entity->dP.y == 0)
{
enum Direction direction = randValue % direction_count;
switch (direction)
{
case direction_north:
case direction_northwest:
{
localDp.x = 1.0f;
localDp.y = 1.0f;
}
break;
case direction_west:
case direction_southwest:
{
localDp.x = -1.0f;
localDp.y = -1.0f;
}
break;
case direction_south:
case direction_southeast:
{
localDp.x = 1.0f;
localDp.y = -1.0f;
}
break;
case direction_east:
case direction_northeast:
{
localDp.x = 1.0f;
localDp.y = 1.0f;
}
break;
default:
{
ASSERT(INVALID_CODE_PATH);
}
break;
}
}
// NOTE(doyle): Otherwise, if it has pre-existing dp, maintain our
// direction by extrapolating from it's current dp
else
{
if (entity->dP.x >= 0)
localDp.x = 1.0f;
else
localDp.x = -1.0f;
if (entity->dP.y >= 0)
localDp.y = 1.0f;
else
localDp.y = -1.0f;
}
/*
NOTE(doyle): We compare current dP with the calculated dP. In the
event we want to artificially boost the asteroid, we set a higher
dP on creation, which will have a higher dP than the default dP
we calculate. So here we choose to keep it until it decays enough
that the default dP of the asteroid is accepted.
*/
v2 newDp = v2_scale(localDp, world->pixelsPerMeter * 1.5f);
f32 newDpSum = ABS(newDp.x) + ABS(newDp.y);
f32 oldDpSum = ABS(entity->dP.x) + ABS(entity->dP.y);
if (newDpSum > oldDpSum)
{
entity->dP = newDp;
}
}
else if (entity->type == entitytype_bullet)
{
if (!math_rectContainsP(world->camera, entity->pos))
{
deleteEntity(world, i--);
continue;
}
Radians rotation = DEGREES_TO_RADIANS((entity->rotation + 90.0f));
v2 localDp = V2(math_cosf(rotation), math_sinf(rotation));
entity->dP = v2_scale(localDp, world->pixelsPerMeter * 5);
}
else if (entity->type == entitytype_particle)
{
f32 diff = entity->color.a - 0.1f;
if (diff < 0.01f)
{
deleteEntity(world, i--);
continue;
}
f32 divisor =
MAX(entity->particleInitDp.x, entity->particleInitDp.y);
f32 maxDp = MAX(entity->dP.x, entity->dP.y);
entity->color.a = maxDp / divisor;
}
entity->pos = wrapPAroundBounds(entity->pos,
math_rectCreate(V2(0, 0), world->size));
/* Loop entity around world */
i32 collisionIndex = moveEntity(world, &state->transientArena, entity,
i, ddP, dt, ddPSpeedInMs);
v4 collideColor = {0};
if (collisionIndex != -1)
{
ASSERT(collisionIndex < world->entityIndex);
Entity *collideEntity = &world->entityList[collisionIndex];
Entity *colliderA;
Entity *colliderB;
if (collideEntity->type < entity->type)
{
colliderA = collideEntity;
colliderB = entity;
}
else
{
colliderA = entity;
colliderB = collideEntity;
}
// Assumptions made that the collision detect system relies on
ASSERT(entitytype_ship < entitytype_asteroid_small);
ASSERT(entitytype_asteroid_small < entitytype_asteroid_medium);
ASSERT(entitytype_asteroid_medium < entitytype_asteroid_large);
ASSERT(entitytype_asteroid_large < entitytype_bullet);
ASSERT(entitytype_asteroid_small + 1 == entitytype_asteroid_medium);
ASSERT(entitytype_asteroid_medium + 1 == entitytype_asteroid_large);
if (colliderA->type >= entitytype_asteroid_small &&
colliderA->type <= entitytype_asteroid_large)
{
f32 numParticles = 4;
if (colliderA->type == entitytype_asteroid_medium)
{
AsteroidSpec spec = {0};
spec.pos = colliderA->pos;
spec.dP = v2_scale(colliderA->dP, -2.0f);
addAsteroidWithSpec(world, asteroidsize_small, &spec);
numParticles = 8;
world->score += (10 * world->scoreMultiplier);
}
else if (colliderA->type == entitytype_asteroid_large)
{
AsteroidSpec spec = {0};
spec.pos = colliderA->pos;
spec.dP = v2_scale(colliderA->dP, -4.0f);
addAsteroidWithSpec(world, asteroidsize_medium, &spec);
spec.dP = v2_perpendicular(spec.dP);
addAsteroidWithSpec(world, asteroidsize_small, &spec);
spec.dP = v2_perpendicular(colliderA->dP);
addAsteroidWithSpec(world, asteroidsize_small, &spec);
numParticles = 16;
world->score += (20 * world->scoreMultiplier);
}
else
{
world->score += (5 * world->scoreMultiplier);
}
for (i32 i = 0; i < numParticles; i++)
{
{ // Add particles
Entity *particle =
&world->entityList[world->entityIndex++];
particle->id = world->entityIdCounter++;
particle->pos = colliderA->pos;
particle->size = V2(4.0f, 4.0f);
i32 randValue = rand();
Radians rotation =
DEGREES_TO_RADIANS((randValue % 360));
v2 randDirectionVec =
V2(math_cosf(rotation), math_sinf(rotation));
i32 particleDpLimit = 8;
f32 randDpMultiplier =
(f32)(randValue % particleDpLimit) + 1;
v2 newDp = v2_scale(colliderA->dP, randDpMultiplier);
newDp = v2_hadamard(newDp, randDirectionVec);
particle->dP = newDp;
particle->particleInitDp = newDp;
particle->offset = v2_scale(particle->size, -0.5f);
particle->hitbox = particle->size;
particle->rotation = 0;
particle->renderMode = rendermode_polygon;
if (!world->particleVertexCache)
{
world->particleVertexCache =
MEMORY_PUSH_ARRAY(&world->entityArena, 4, v2);
world->particleVertexCache[0] =
V2(0, particle->size.h);
world->particleVertexCache[1] = V2(0, 0);
world->particleVertexCache[2] =
V2(particle->size.w, 0);
world->particleVertexCache[3] = particle->size;
}
particle->vertexPoints = world->particleVertexCache;
particle->numVertexPoints = 4;
particle->type = entitytype_particle;
particle->color = V4(1.0f, 0.0f, 0, 1.0f);
}
}
ASSERT(colliderB->type == entitytype_bullet);
deleteEntity(world, collisionIndex);
deleteEntity(world, i--);
world->asteroidCounter--;
ASSERT(world->asteroidCounter >= 0);
char *sound;
i32 choice = rand() % 3;
if (choice == 0)
{
sound = "bang_small";
}
else if (choice == 1)
{
sound = "bang_medium";
}
else
{
sound = "bang_large";
}
AudioVorbis *explode =
asset_vorbisGet(&state->assetManager, sound);
AudioRenderer *audioRenderer =
getFreeAudioRenderer(world, explode, 3);
if (audioRenderer)
{
audio_vorbisPlay(&state->transientArena,
&state->audioManager, audioRenderer,
explode, 1);
}
continue;
}
else if (colliderA->type == entitytype_ship)
{
if (colliderB->type >= entitytype_asteroid_small &&
colliderB->type <= entitytype_asteroid_large)
{
world->flags |= gameworldstateflags_player_lost;
if (collideEntity->type == entitytype_ship)
{
deleteEntity(world, collisionIndex);
}
else
{
deleteEntity(world, i--);
}
AudioVorbis *explode =
asset_vorbisGet(&state->assetManager, "bang_large");
AudioRenderer *audioRenderer =
getFreeAudioRenderer(world, explode, 3);
if (audioRenderer)
{
audio_vorbisPlay(&state->transientArena,
&state->audioManager, audioRenderer,
explode, 1);
}
continue;
}
}
}
RenderFlags flags = renderflag_wireframe | renderflag_no_texture;
renderer_entity(&state->renderer, &state->transientArena, world->camera,
entity, V2(0, 0), 0, collideColor, 0, flags);
}
for (i32 i = 0; i < world->numAudioRenderers; i++)
{
AudioRenderer *audioRenderer = &world->audioRenderer[i];
audio_updateAndPlay(&state->transientArena, &state->audioManager,
audioRenderer);
}
}
