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

8
code/game/aabb.h
View File

@@ -3,15 +3,15 @@
#include "../core/types.h"
#include "../core/macros.h"
typedef struct AABB AABB;
struct AABB {
struct AABB
{
V2f pos;
V2f size;
};
function bool AABB_Collide(AABB a, AABB b);
function bool AABB_Point(AABB a, V2f v);
function bool AABB_Slab(V2f origin, V2f point, AABB a);
#endif // LD_GAME_AABB_H_
#endif // LD_GAME_AABB_H_

3
code/game/bandit.h
View File

@@ -6,7 +6,7 @@ enum BANDIT_ACTION {
BANDIT_WAITING,
BANDIT_WALKING,
BANDIT_RUNNING,
BANDIT_SHOOTOUT,
BANDIT_SHOOTING,
};
typedef struct Bandit Bandit;
@@ -22,6 +22,7 @@ struct Bandit {
// How long they will wait in this location.
F32 maxWaitTime;
U32 poiCount;
// Places the bandit walks to / from
// E.g. hide outs, home, saloon
U32 pointsOfInterest[12];

4
code/game/core.h
View File

@@ -1,5 +1,6 @@
#if !defined(LD_GAME_CORE_H_)
#define LD_GAME_CORE_H_
#include "world.h"
typedef struct G_Camera G_Camera;
struct G_Camera {
@@ -18,6 +19,8 @@ struct G_State {
D_Context draw;
G_Camera camera;
World *world;
};
function void G_ImagesLoad(G_State *game);
@@ -35,6 +38,5 @@ function R3f G_CameraBounds(G_Camera *camera);
#include "player.h"
#include "nav.h"
#include "npc.h"
#include "world.h"
#endif // LD_GAME_CORE_H_

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) {

6
code/game/npc.h
View File

@@ -5,7 +5,7 @@
#include "npc_look.h"
#include "../core/types.h"
#define NPC_SPEED 0.2f
#define NPC_SPEED 1.0f
typedef enum NPC_ACTION NPC_ACTION;
enum NPC_ACTION {
@@ -23,6 +23,10 @@ struct NPC {
Str8 name;
NPC_LOOK look;
bool customPOI;
U32 customPOICount;
U32 npcPOI[16];
//// Actions
NPC_ACTION mode;
// How long they've been waiting

21
code/game/player.h
View File

@@ -6,12 +6,31 @@
#include <SDL3/SDL_events.h>
#define PLAYER_SPEED 10.0f
#define PLAYER_RELOAD_TIME 1.5f
#define PLAYER_BULLET_COUNT 6
typedef struct ControlState ControlState;
struct ControlState {
bool rightDown;
bool leftDown;
bool upDown;
bool downDown;
bool shot;
};
typedef struct Player Player;
struct Player
{
V2f pos;
U32 bulletsLoaded;
ControlState controls;
V2f shotPos;
F32 reloadTimer;
};
function void PlayerUpdate(SDL_Event *event, Player *player);
function void PlayerInput(SDL_Event *event, Player *player);
function void PlayerUpdate(F32 delta, Player *player);
#endif // LD_GAME_PLAYER_H_

8
code/game/world.h
View File

@@ -4,6 +4,7 @@
#include "player.h"
#include "npc.h"
#include "bandit.h"
#include "../core/math.h"
// Areas are which
typedef U32 World_Area;
@@ -16,6 +17,7 @@ typedef struct World World;
struct World {
//// Static stuff
NavMesh *navMesh;
Random random;
//// Player
Player player;
@@ -33,10 +35,10 @@ struct World {
};
function void UpdateWorld(F32 delta, World *world);
function void RenderWorld(World *world, D_Context *drawContext );
function void ProcessEvents(SDL_Event *event, World *world);
function void UpdateNPCs(F32 delta, World *world);
function void updateNPC(F32 delta, NPC *npc, World *world);
function void G_WorldDraw(G_State *game, World *world);
function void UpdateNPC(F32 delta, NPC *npc, World *world);
function void UpdateBandit(F32 delta, Bandit *bandit, World *world);
#endif // LD_GAME_WORLD_H_