bulmanator/ld58
1
0
Fork 0
Code Issues 12 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Merge branch 'main' of yibble.dev:bulmanator/ld58

Browse Source
This commit is contained in:
James Bulman
2025-10-05 21:19:14 +01:00
parent eb3c81cd04 635e7b1c1e
commit 3eb8683ce3
17 changed files with 335 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
code/game/impl/aabb.c
View File

@@ -1,15 +1,36 @@
#include "game/aabb.h"
#include "core/types.h"
#include <math.h>
bool AABB_Collide(AABB a, AABB b) {
bool AABB_Collide(AABB a, AABB b)
{
bool collision_x = a.pos.x + a.size.x >= b.pos.x && b.pos.x + b.size.x >= a.pos.x;
bool collision_y = a.pos.y + a.size.x >= b.pos.y && b.pos.y + b.size.y >= a.pos.y;
return collision_x && collision_y;
}
bool AABB_Point(AABB a, V2f v) {
bool AABB_Point(AABB a, V2f v)
{
bool collision_x = a.pos.x + a.size.x >= v.x && a.pos.x <= v.x;
bool collision_y = a.pos.x + a.size.y >= v.y && a.pos.y <= v.y;
return collision_x && collision_y;
}
bool AABB_Slab(V2f origin, V2f point, AABB a)
{
V2f start = a.pos;
V2f finish = {a.pos.x + a.size.x, a.pos.y + a.size.y};
V2f invdirection = {1 / (origin.x - point.x), 1 / (origin.y - point.y)};
// x
F32 tLow = (start.x - origin.x) * invdirection.x;
F32 tHigh = (finish.x - origin.x) * invdirection.x;
F32 tMin = Min(tLow, tHigh);
F32 tMax = Max(tLow, tHigh);
// y
tLow = (start.y - origin.y) * invdirection.y;
tHigh = (finish.y - origin.y) * invdirection.y;
tMin = Max(tMin, Min(tLow, tHigh));
tMax = Min(tMax, Max(tLow, tHigh));
return tMax >= tMin;
}

41
code/game/impl/bandit.c Normal file
View File

@@ -0,0 +1,41 @@
#include "game/world.h"
#include "game/bandit.h"
void UpdateBandit(F32 delta, Bandit *bandit, World *world) {
switch (bandit->mode) {
case BANDIT_WAITING:
bandit->waitTime+=delta;
if(bandit->waitTime > bandit->maxWaitTime) {
bandit->mode = BANDIT_WALKING;
do {
U32 randomChoice = Random_U32(&world->random, 0, bandit->poiCount);
bandit->targetNavNode = bandit->pointsOfInterest[randomChoice];
} while(bandit->targetNavNode == bandit->currentNavNode);
bandit->path = Nav_Path(world->navMesh, bandit->currentNavNode, bandit->targetNavNode);
bandit->walkTimer = 0;
}
break;
case BANDIT_WALKING:
bandit->walkTimer+=delta;
if(bandit->walkTimer >= NPC_SPEED){
bandit->walkTimer = 0;
if(bandit->path.nodeCount == bandit->pathIndex+1){
bandit->mode = BANDIT_WAITING;
bandit->maxWaitTime = Random_F32(&world->random, 20, 140);
bandit->waitTime = 0;
bandit->currentNavNode = bandit->targetNavNode;
bandit->pathIndex = 0;
return;
}
bandit->currentNavNode = bandit->path.indexes[bandit->pathIndex];
bandit->pathIndex+=1;
}
NavNode cNav = world->navMesh->nodes[bandit->currentNavNode];
NavNode tNav = world->navMesh->nodes[bandit->path.indexes[bandit->pathIndex]];
bandit->collision.pos.x = cNav.pos.x * (1 - bandit->walkTimer/NPC_SPEED) + tNav.pos.x * bandit->walkTimer/NPC_SPEED;
bandit->collision.pos.y = cNav.pos.y * (1 - bandit->walkTimer/NPC_SPEED) + tNav.pos.y * bandit->walkTimer/NPC_SPEED;
break;
// TODO Shooting
// TODO Running away
}
}

62
code/game/impl/nav.c
View File

@@ -6,45 +6,54 @@
#define MAX_UNFINISHED 128
typedef struct navSearchNodeState navSearchNodeState;
struct navSearchNodeState{
struct navSearchNodeState
{
bool visited;
U64 distance;
F64 distance;
U32 shortest;
bool addedToUnvisited;
};
typedef struct navSearchState navSearchState;
struct navSearchState{
struct navSearchState
{
navSearchNodeState nodeStates[NAV_MAX_NODES];
};
navSearchState initState(U32 start, U32 meshSize) {
navSearchState state = {};
for(U32 i = 0; i < meshSize; i++) {
state.nodeStates[i].visited = false;
navSearchState initState(U32 start, U32 meshSize)
{
navSearchState state;
for (U32 i = 0; i < meshSize; i++)
{
state.nodeStates[i].visited = false;
state.nodeStates[i].addedToUnvisited = false;
state.nodeStates[i].distance = U64_MAX;
state.nodeStates[i].shortest = 0;
state.nodeStates[i].distance = F64_MAX;
state.nodeStates[i].shortest = 0;
}
state.nodeStates[start].distance = 0;
return state;
}
U32 getLowestState(U32 unfinishedIndexes[128], U32 unfinishedCount, navSearchState state, U32 *offset) {
U32 lowest = U32_MAX;
U32 getLowestState(U32 unfinishedIndexes[128], U32 unfinishedCount, navSearchState state, U32 *offset)
{
U32 lowest = U32_MAX;
U32 lowestI = U32_MAX;
bool startFound = false;
for(U32 i = *offset; i < unfinishedCount; i++) {
for (U32 i = *offset; i < unfinishedCount; i++)
{
navSearchNodeState checkNode = state.nodeStates[unfinishedIndexes[i]];
if(checkNode.visited) {
if(!startFound) {
if (checkNode.visited)
{
if (!startFound)
{
*offset = i;
}
continue;
}
startFound = true;
if (lowest > checkNode.distance) {
lowest = cast(U32) checkNode.distance;
if (lowest > checkNode.distance)
{
lowest = cast(U32) checkNode.distance;
lowestI = unfinishedIndexes[i];
}
}
@@ -53,6 +62,12 @@ U32 getLowestState(U32 unfinishedIndexes[128], U32 unfinishedCount, navSearchSta
// Generate a path to follow between the start and end node.
NavPath Nav_Path(NavMesh *mesh, U32 start, U32 end) {
// This is a stupid fix, since it's easier to work backwards
// to generate a path, I'm swapping the start / end, to generate
// it backwards
U32 tmp = end;
end = start;
start = tmp;
navSearchState state = initState(start, mesh->nodeCount);
U32 unfinishedCount = 1;
U32 unfinishedIndexes[NAV_MAX_NODES] = {start};
@@ -68,14 +83,15 @@ NavPath Nav_Path(NavMesh *mesh, U32 start, U32 end) {
NavConnection *connection = &mesh->nodes[lowestNodeIndex].connections[connectionI];
navSearchNodeState *testNode = &state.nodeStates[connection->NodeIndex];
if(testNode->visited) {continue;}
U32 distance = cast(U32) (state.nodeStates[lowestNodeIndex].distance + connection->Cost);
distance += cast(U32) (mesh->nodes[end].pos.x - mesh->nodes[connection->NodeIndex].pos.x);
distance += cast(U32) (mesh->nodes[end].pos.y - mesh->nodes[connection->NodeIndex].pos.y);
F64 distance = cast(F64) (state.nodeStates[lowestNodeIndex].distance + connection->Cost);
distance += cast(F64) Abs((mesh->nodes[end].pos.x - mesh->nodes[connection->NodeIndex].pos.x));
distance += cast(F64) Abs((mesh->nodes[end].pos.y - mesh->nodes[connection->NodeIndex].pos.y));
if(testNode->distance > distance) {
testNode->distance = distance;
testNode->shortest = lowestNodeIndex;
}
if(!testNode->addedToUnvisited) {
if (!testNode->addedToUnvisited)
{
unfinishedIndexes[unfinishedCount] = connection->NodeIndex;
unfinishedCount++;
testNode->addedToUnvisited = true;
@@ -83,13 +99,15 @@ NavPath Nav_Path(NavMesh *mesh, U32 start, U32 end) {
}
state.nodeStates[lowestNodeIndex].visited = true;
lowestNodeIndex = getLowestState(unfinishedIndexes, unfinishedCount, state, &unfinishedOffset);
if(lowestNodeIndex == end) {
if (lowestNodeIndex == end)
{
found = true;
}
}
NavPath res_path = {0};
U32 index = end;
while(index!=start) {
while (index != start)
{
res_path.indexes[res_path.nodeCount] = index;
res_path.nodeCount++;
index = state.nodeStates[index].shortest;

24
code/game/impl/npc.c
View File

@@ -1,22 +1,22 @@
#include "game/npc.h"
#include "game/world.h"
#include "core/types.h"
#include "core/math.h"
#include <stdio.h>
void updateNPC(F32 delta, NPC *npc, World *world) {
void UpdateNPC(F32 delta, NPC *npc, World *world) {
switch (npc->mode) {
case NPC_ACTION_WAITING:
npc->waitTime+=delta;
if(npc->waitTime > npc->maxWaitTime) {
npc->mode = NPC_ACTION_WALKING;
U32 next = npc->targetNavNode == 100 ? 20 : 100;
npc->targetNavNode = next; // TODO RANDOM
printf("Starting to nav path\n");
// TODO change targets to poi's rather than just random nodes
// TODO choose either global POI's or use NPC custom poi if
// customPOI is true
do {
npc->targetNavNode = Random_U32(&world->random, 0, world->navMesh->nodeCount);
} while(npc->targetNavNode == npc->currentNavNode);
npc->path = Nav_Path(world->navMesh, npc->currentNavNode, npc->targetNavNode);
printf("done\n");
npc->walkTimer = 0;
printf("%.*s started walking to %d\n", Sv(npc->name), npc->targetNavNode);
}
break;
case NPC_ACTION_WALKING:
@@ -24,18 +24,18 @@ void updateNPC(F32 delta, NPC *npc, World *world) {
if(npc->walkTimer >= NPC_SPEED){
npc->walkTimer = 0;
if(npc->path.nodeCount == npc->pathIndex+1){
printf("Finished! so I'm waiting\n");
npc->mode = NPC_ACTION_WAITING;
npc->maxWaitTime = 20; // TODO RANDOM
npc->maxWaitTime = Random_F32(&world->random, 20, 140);
npc->waitTime = 0;
npc->currentNavNode = npc->targetNavNode;
npc->pathIndex = 0;
return;
}
npc->pathIndex+=1;
npc->currentNavNode = npc->path.indexes[npc->pathIndex];
npc->pathIndex+=1;
}
NavNode cNav = world->navMesh->nodes[npc->currentNavNode];
NavNode tNav = world->navMesh->nodes[npc->pathIndex];
NavNode tNav = world->navMesh->nodes[npc->path.indexes[npc->pathIndex]];
npc->collision.pos.x = cNav.pos.x * (1 - npc->walkTimer/NPC_SPEED) + tNav.pos.x * npc->walkTimer/NPC_SPEED;
npc->collision.pos.y = cNav.pos.y * (1 - npc->walkTimer/NPC_SPEED) + tNav.pos.y * npc->walkTimer/NPC_SPEED;
break;

74
code/game/impl/player.c
View File

@@ -1,26 +1,78 @@
#include "../player.h"
#include <SDL3/SDL_events.h>
#include <SDL3/SDL_keycode.h>
#include <stdio.h>
void PlayerUpdate(SDL_Event *event, Player *player)
void PlayerInput(SDL_Event *event, Player *player)
{
SDL_KeyboardEvent key = event->key;
switch(key.key) {
case SDLK_W: {
player->pos.y += 10;
player->controls.shot = false;
SDL_KeyboardEvent key = event->key;
SDL_MouseButtonEvent mouseBtn = event->button;
if(event->type == SDL_EVENT_KEY_DOWN || event->type == SDL_EVENT_KEY_UP) {
bool val = event->type == SDL_EVENT_KEY_DOWN;
switch (key.key)
{
case SDLK_W:
{
player->controls.upDown = val;
break;
}
case SDLK_A: {
player->pos.x -= 10;
case SDLK_A:
{
player->controls.leftDown = val;
break;
}
case SDLK_D: {
player->pos.x += 10;
case SDLK_D:
{
player->controls.rightDown = val;
break;
}
case SDLK_S: {
player->pos.y -= 10;
case SDLK_S:
{
player->controls.downDown = val;
break;
}
}
}
if (
event->type == SDL_EVENT_MOUSE_BUTTON_DOWN
&& mouseBtn.button == SDL_BUTTON_LEFT
) {
if(player->bulletsLoaded > 0) {
// shooting
player->bulletsLoaded -= 1;
player->controls.shot = true;
player->shotPos = V2F(mouseBtn.x, mouseBtn.y);
printf("shot %f %f\n", mouseBtn.x, mouseBtn.y);
} else if(player->reloadTimer == 0) {
player->reloadTimer = PLAYER_RELOAD_TIME;
printf("reloading\n");
};
}
}
void PlayerUpdate(F32 delta, Player *player) {
V2f dir = V2F(0, 0);
if(player->controls.upDown) {
dir.y -= 1;
}
if(player->controls.downDown) {
dir.y += 1;
}
if(player->controls.leftDown) {
dir.x -= 1;
}
if(player->controls.rightDown) {
dir.x += 1;
}
if(player->reloadTimer > 0) {
player->reloadTimer-=delta;
if(player->reloadTimer <= 0) {
player->bulletsLoaded = PLAYER_BULLET_COUNT;
player->reloadTimer = 0;
}
}
dir = V2f_Scale(NormaliseV2F(dir), PLAYER_SPEED*delta);
player->pos.x += dir.x;
player->pos.y += dir.y;
}

32
code/game/impl/world.c
View File

@@ -3,18 +3,38 @@
#include "../player.h"
#include <SDL3/SDL_events.h>
void UpdateWorld(F32 delta, World *world) {
void UpdateWorld(F32 delta, World *world)
{
UpdateBandit(delta, &world->bandit, world);
UpdateNPCs(delta, world);
PlayerUpdate(delta, &world->player);
}
void UpdateNPCs(F32 delta, World *world) {
for(U32 i = 0; i < world->npcCount; i++) {
updateNPC(delta, &world->npcs[i], world);
void UpdateNPCs(F32 delta, World *world)
{
for (U32 i = 0; i < world->npcCount; i++)
{
UpdateNPC(delta, &world->npcs[i], world);
if(world->player.controls.shot && AABB_Point(world->npcs[i].collision, world->player.shotPos)) {
// TODO we need to unproject the mouse location !!!
printf("You shot %.*s\n", Sv(world->npcs[i].name));
}
}
}
void ProcessEvents(SDL_Event *event, World *world) {
PlayerUpdate(event, &world->player);
void ProcessEvents(SDL_Event *event, World *world)
{
PlayerInput(event, &world->player);
}
void RenderWorld(World *world, D_Context *draw) {
for(U32 i = 0; i < world->npcCount; i++) {
NPC npc = world->npcs[i];
D_Rect(draw, npc.collision.pos.x, npc.collision.pos.y, .texture = 1);
D_Rect(draw, npc.collision.pos.x, npc.collision.pos.y, .texture = 0, .dim = npc.collision.size);
}
D_Rect(draw, world->bandit.collision.pos.x, world->bandit.collision.pos.y, .texture = 9);
D_Rect(draw, world->player.pos.x, world->player.pos.y, .texture = 1);
}
void G_WorldDraw(G_State *game, World *world) {