abdelrahman/dod-test
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Switch position, scale and velocity to i16

Browse Source
This commit is contained in:
Abdelrahman Said 2025-05-24 00:19:23 +01:00
parent 60df7c5fbb
commit c6cac7be8a
3 changed files with 68 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -1,6 +1,6 @@
CC = clang
CFLAGS = -g -O3 -Iraylib/include -Iwapp/src
LDFLAGS = '-Wl,-rpath,$$ORIGIN/raylib/lib' -Lraylib/lib -lraylib
LDFLAGS = '-Wl,-rpath,$$ORIGIN/raylib/lib' -Lraylib/lib -lraylib -lm
BASEDIR = $(shell realpath ./)
RL_SRCDIR = ${BASEDIR}/raylib-src/src
RL_BUILDDIR = ${BASEDIR}/raylib-build

3
common.h
View File

@ -7,6 +7,8 @@
#define MAX_WANDERER_DIM 8
#define MIN_WANDERER_DIM 3
#define MIN_ZONE_DIM 30
#define MIN_ABS_VELOCITY 200
#define MAX_ABS_VELOCITY 600
#define BG_COLOR (Color){.r = 0xea, .g = 0xf2, .b = 0xe3, .a = 0xff}
#define FG_COLOR (Color){.r = 0x42, .g = 0x4C, .b = 0x55, .a = 0xff}
#define ZONE_COLOR (Color){.r = 0xb4, .g = 0x65, .b = 0x4a, .a = 0xff}
@ -15,6 +17,7 @@
#define WANDERER_SLOWDOWN_FACTOR 0.5f
#define WANDERER_SPEEDUP_FACTOR 2.0f
#define MSG_BUF_LEN 4096
#define abs(A) (A < 0 ? A * -1 : A)
#define min(A, B) (A < B ? A : B)
#define max(A, B) (A > B ? A : B)

111
dod.c
View File

@ -1,6 +1,7 @@
#include "wapp.h"
#include "common.h"
#include "raylib.h"
#include <math.h>
#include <stdint.h>
#include <stdbool.h>
#include <assert.h>
@ -25,14 +26,14 @@ struct Entity {
typedef struct Position Position;
struct Position {
f32 x;
f32 y;
i16 x;
i16 y;
};
typedef struct Scale Scale;
struct Scale {
f32 width;
f32 height;
i16 width;
i16 height;
};
typedef struct Rect Rect;
@ -43,8 +44,8 @@ struct Rect {
typedef struct Velocity Velocity;
struct Velocity {
f32 x;
f32 y;
i16 x;
i16 y;
};
typedef struct Manager Manager;
@ -66,15 +67,17 @@ void init_scale_wanderer(Scale *scale, XOR256State *state);
void init_scale_zone(Scale *scale, XOR256State *state);
void init_velocity(Velocity *velocity, XOR256State *state);
void zero_velocity(Velocity *velocity, XOR256State *state);
void update_positions(u8 *tags, Rect *rects, Velocity *velocities, u64 count);
void update_positions(u8 *tags, Rect *rects, Velocity *velocities, u64 count, f32 delta);
void render_entities(const u8 *tags, const Rect *rects, u64 count);
u64 collides(const Rect *rect, const Rect *collider);
f32 get_random_float(XOR256State *state);
u8 collides(const Rect *rect, const Rect *collider);
i16 get_random_velocity(XOR256State *state);
int main(void) {
i32 target_fps = 120;
SetTraceLogLevel(LOG_NONE);
InitWindow(WIDTH, HEIGHT, "DOD test");
// SetTargetFPS(120);
// SetTargetFPS(target_fps);
Allocator arena = wapp_mem_arena_allocator_init(MB(20));
assert(!wapp_mem_allocator_invalid(&arena));
@ -98,13 +101,19 @@ int main(void) {
velocity_initialisers[is_zone](&(manager.velocities[i]), &state);
}
f32 last_time = GetFrameTime();
f32 delta, cur_time;
while (!WindowShouldClose()) {
f64 time = GetTime();
if (time >= 20.0) {
break;
}
update_positions(manager.tags, manager.rects, manager.velocities, manager.count);
cur_time = GetFrameTime();
delta = cur_time - last_time;
update_positions(manager.tags, manager.rects, manager.velocities, manager.count, delta);
BeginDrawing();
@ -127,13 +136,15 @@ int main(void) {
void init_manager(const Allocator *allocator, Manager *manager) {
assert(allocator != NULL && manager != NULL);
u64 total_count = (u64)WANDERER_COUNT + (u64)ZONE_COUNT;
u64 entities_size = sizeof(Entity) * total_count;
u64 rects_size = sizeof(Rect) * total_count;
u64 velocities_size = sizeof(Velocity) * total_count;
u64 tags_size = sizeof(u8) * total_count;
u64 allocation_size = entities_size + rects_size + velocities_size + tags_size;
u8 *buffer = wapp_mem_allocator_alloc(allocator, allocation_size);
u64 total_count = (u64)WANDERER_COUNT + (u64)ZONE_COUNT;
total_count += 4 - (total_count % 4);
u64 entities_size = sizeof(Entity) * total_count;
u64 rects_size = sizeof(Rect) * total_count;
u64 velocities_size = sizeof(Velocity) * total_count;
u64 tags_size = sizeof(u8) * total_count;
u64 allocation_size = entities_size + rects_size + velocities_size + tags_size;
u8 *buffer = wapp_mem_allocator_alloc(allocator, allocation_size);
assert(buffer != NULL);
@ -147,24 +158,24 @@ void init_manager(const Allocator *allocator, Manager *manager) {
}
void init_position(Position *position, XOR256State *state) {
position->x = wapp_prng_xorshift_256(state) % WIDTH;
position->y = wapp_prng_xorshift_256(state) % HEIGHT;
position->x = wapp_prng_xorshift_256ss(state) % WIDTH;
position->y = wapp_prng_xorshift_256ss(state) % HEIGHT;
}
void init_scale_wanderer(Scale *scale, XOR256State *state) {
f32 value = (f32)((wapp_prng_xorshift_256(state) % (MAX_WANDERER_DIM + 1 - MIN_WANDERER_DIM)) + MIN_WANDERER_DIM);
i16 value = (i16)((wapp_prng_xorshift_256p(state) % (MAX_WANDERER_DIM + 1 - MIN_WANDERER_DIM)) + MIN_WANDERER_DIM);
scale->width = value;
scale->height = value;
}
void init_scale_zone(Scale *scale, XOR256State *state) {
scale->width = wapp_prng_xorshift_256(state) % ((u64)HALF_WIDTH - MIN_ZONE_DIM) + MIN_ZONE_DIM;
scale->height = wapp_prng_xorshift_256(state) % ((u64)HALF_HEIGHT - MIN_ZONE_DIM) + MIN_ZONE_DIM;
scale->width = wapp_prng_xorshift_256p(state) % ((u64)HALF_WIDTH - MIN_ZONE_DIM) + MIN_ZONE_DIM;
scale->height = wapp_prng_xorshift_256p(state) % ((u64)HALF_HEIGHT - MIN_ZONE_DIM) + MIN_ZONE_DIM;
}
void init_velocity(Velocity *velocity, XOR256State *state) {
velocity->x = get_random_float(state);
velocity->y = get_random_float(state);
velocity->x = get_random_velocity(state);
velocity->y = get_random_velocity(state);
}
void zero_velocity(Velocity *velocity, XOR256State *state) {
@ -172,10 +183,12 @@ void zero_velocity(Velocity *velocity, XOR256State *state) {
velocity->y = 0.0f;
}
void update_positions(u8 *tags, Rect *rects, Velocity *velocities, u64 count) {
void update_positions(u8 *tags, Rect *rects, Velocity *velocities, u64 count, f32 delta) {
u8 index = 0;
f32 multipliers[2] = {1.0f, 0.5f};
persistent u64 inside_zone_mask = 0x7;
f32 pos_x, pos_y;
f32 max_x, max_y;
for (u64 i = ZONE_COUNT; i < count; ++i) {
tags[i] &= inside_zone_mask;
@ -185,21 +198,24 @@ void update_positions(u8 *tags, Rect *rects, Velocity *velocities, u64 count) {
index = (tags[i] & ENTITY_TAG_INSIDE_ZONE) >> INSIDE_ZONE_TAG_SHIFT;
rects[i].position.x += velocities[i].x * multipliers[index];
rects[i].position.y += velocities[i].y * multipliers[index];
max_x = WIDTH - rects[i].scale.width;
max_y = HEIGHT - rects[i].scale.height;
f32 max_x = WIDTH - rects[i].scale.width;
f32 max_y = HEIGHT - rects[i].scale.height;
pos_x = rects[i].position.x + velocities[i].x * multipliers[index] * delta;
pos_y = rects[i].position.y + velocities[i].y * multipliers[index] * delta;
if (rects[i].position.x < 0 || rects[i].position.x >= max_x) {
rects[i].position.x = min(max(rects[i].position.x, 0), max_x);
if (pos_x < 0 || pos_x >= max_x) {
pos_x = min(max(pos_x, 0), max_x);
velocities[i].x *= -1;
}
if (rects[i].position.y < 0 || rects[i].position.y >= max_y) {
rects[i].position.y = min(max(rects[i].position.y, 0), max_y);
if (pos_y < 0 || pos_y >= max_y) {
pos_y = min(max(pos_y, 0), max_y);
velocities[i].y *= -1;
}
rects[i].position.x = roundf(pos_x);
rects[i].position.y = roundf(pos_y);
}
}
@ -221,22 +237,23 @@ void render_entities(const u8 *tags, const Rect *rects, u64 count) {
}
}
u64 collides(const Rect *rect, const Rect *collider) {
f32 rect_min_x = rect->position.x + rect->scale.width;
f32 rect_min_y = rect->position.y + rect->scale.height;
f32 rect_max_x = rect->position.x;
f32 rect_max_y = rect->position.y;
u8 collides(const Rect *rect, const Rect *collider) {
i16 rect_min_x = rect->position.x + rect->scale.width;
i16 rect_min_y = rect->position.y + rect->scale.height;
i16 rect_max_x = rect->position.x;
i16 rect_max_y = rect->position.y;
f32 zone_x0 = collider->position.x;
f32 zone_y0 = collider->position.y;
f32 zone_x1 = collider->position.x + collider->scale.width;
f32 zone_y1 = collider->position.y + collider->scale.height;
i16 zone_x0 = collider->position.x;
i16 zone_y0 = collider->position.y;
i16 zone_x1 = collider->position.x + collider->scale.width;
i16 zone_y1 = collider->position.y + collider->scale.height;
return (u64)(rect_min_x > zone_x0 && rect_min_y > zone_y0 &&
return (u8)(rect_min_x > zone_x0 && rect_min_y > zone_y0 &&
rect_max_x < zone_x1 && rect_max_y < zone_y1);
}
f32 get_random_float(XOR256State *state) {
i64 random = (i64)wapp_prng_xorshift_256(state) - INT64_MAX;
return (f32)(random) / (f32)(INT64_MAX);
i16 get_random_velocity(XOR256State *state) {
// i64 random = (i64)wapp_prng_xorshift_256(state) - INT64_MAX;
// return (f32)(random) / (f32)(INT64_MAX);
return (wapp_prng_xorshift_256(state) % (MAX_ABS_VELOCITY + 1 - MIN_ABS_VELOCITY)) + MIN_ABS_VELOCITY;
}