wholeworldcoding/WrldBox
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Scale factor and expansion upon basic implementation

Browse Source
This commit is contained in:
octolinkyt
2026-06-15 11:54:39 -04:00
committed by P7MJ
parent c4930f77df
commit 4b545205aa
19 changed files with 2400 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
Makefile
View File

@@ -1,21 +1,22 @@
# 1. Variables (to avoid repeating yourself)
CC=gcc CC=gcc
CFLAGS = -Iinclude
LDFLAGS = -Llib -lraylib -lGL -lm -lpthread -ldl -lrt -lX11
# 2. Default target (runs when you just type 'make') SRC=src/main.c \
default: visual text src/world.c \
src/player.c \
src/physics.c \
src/render.c
# 3. Specific build targets OUT=wrldbox
visual: ray.c
$(CC) ray.c -o ray.out $(CFLAGS) $(LDFLAGS)
text: text_physics.c INCLUDES=-Iinclude
$(CC) text_physics.c -o text_physics.out $(CFLAGS) $(LDFLAGS) LIBPATH=-Llib
# 4. Cleanup targets (all mapped to the same action) CFLAGS=-O2 -Wall
clean clear rm remove wipe:
rm -f ray.out text_physics.out
# 5. Phony targets (tells make these are actions, not actual files) LIBS=-lraylib -lX11 -ldl -lpthread -lm
.PHONY: default visual text clean clear rm remove wipe
all:
$(CC) $(SRC) $(CFLAGS) $(INCLUDES) $(LIBPATH) -o $(OUT) $(LIBS)
clean:
rm -f $(OUT)

21
OLD/Makefile Normal file
View File

@@ -0,0 +1,21 @@
# 1. Variables (to avoid repeating yourself)
CC = gcc
CFLAGS = -Iinclude
LDFLAGS = -Llib -lraylib -lGL -lm -lpthread -ldl -lrt -lX11
# 2. Default target (runs when you just type 'make')
default: visual text
# 3. Specific build targets
visual: ray.c
$(CC) ray.c -o ray.out $(CFLAGS) $(LDFLAGS)
text: text_physics.c
$(CC) text_physics.c -o text_physics.out $(CFLAGS) $(LDFLAGS)
# 4. Cleanup targets (all mapped to the same action)
clean clear rm remove wipe:
rm -f ray.out text_physics.out
# 5. Phony targets (tells make these are actions, not actual files)
.PHONY: default visual text clean clear rm remove wipe

0
README.md → OLD/README.md
View File

1743
OLD/include/raylib.h Executable file
View File

File diff suppressed because it is too large Load Diff

BIN
OLD/lib/libraylib.a Executable file
View File

Binary file not shown.

6
ray.c → OLD/ray.c
View File

@@ -4,12 +4,14 @@
// Changes: // Changes:
// Reversing gravity makes it work?!!! // Reversing gravity makes it work?!!!
// Added scale factor, mathed the shit out of that.
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "raylib.h" #include "raylib.h"
const float g = 9.81; // Gravity is inversed cause raylib uses top right corner as origin const float scale=43.7445319335; // We must find a scale factor, as gravity is calculated based on PIXELS rather than METERS. We say the character is 3 ft so we divide 40 pixels by the equvalent amount of meters for 3ft which is .9144. so 40/.9144 to get what one pixel is in terms of meters. Left as a variable because this will probably be recalculated eventually.
const float g = 9.81*scale; // Gravity is inversed cause raylib uses top right corner as origin.
float obj_x = 100; // Starting X (pixels) float obj_x = 100; // Starting X (pixels)
float obj_y = 100; // Starting Y (pixels) float obj_y = 100; // Starting Y (pixels)
float obj_vel_x = 50; // Velocity X (pixels/second) float obj_vel_x = 50; // Velocity X (pixels/second)
@@ -22,7 +24,7 @@ int main(void) {
const int screenWidth = 800; const int screenWidth = 800;
const int screenHeight = 600; const int screenHeight = 600;
InitWindow(screenWidth, screenHeight, "Physics Engine - Falling Rectangle"); InitWindow(screenWidth, screenHeight, "WrldBox // ray.c");
SetTargetFPS(60); // 60 frames per second SetTargetFPS(60); // 60 frames per second
float deltaTime = 0.0f; float deltaTime = 0.0f;

0
structure.txt → OLD/structure.txt
View File

0
text_physics.c → OLD/text_physics.c
View File

21
src/config.h Normal file
View File

@@ -0,0 +1,21 @@
#ifndef CONFIG_H
#define CONFIG_H
#define MAX_ENTITIES 512
extern const float scale;
extern const float g;
extern const float PLAYER_FORCE;
extern const float JUMP_FORCE;
extern const float AIR_DRAG;
extern const float GROUND_FRICTION;
extern const float MAX_PLAYER_SPEED;
extern const float BOUNCE;
extern const float ground_y;
#endif

26
src/entity.h Normal file
View File

@@ -0,0 +1,26 @@
#ifndef ENTITY_H
#define ENTITY_H
#include <stdbool.h>
#include "raylib.h"
typedef struct Entity
{
bool active;
bool isPlayer;
bool affectedByGravity;
float mass;
float size;
Vector2 position;
Vector2 velocity;
Vector2 acceleration;
Vector2 force;
Color color;
} Entity;
#endif

172
src/main.c Normal file
View File

@@ -0,0 +1,172 @@
#include <stdio.h>
#include "raylib.h"
#include "world.h"
#include "physics.h"
#include "player.h"
#include "render.h"
#include "config.h"
int main(void)
{
const int screenWidth = 1000;
const int screenHeight = 600;
InitWindow(
screenWidth,
screenHeight,
"WrldBox Sandbox");
SetTargetFPS(60);
InitWorld();
printf("WrldBox Sandbox Started\n");
printf("Gravity = %.2f\n", g);
while (!WindowShouldClose())
{
float dt = GetFrameTime();
if (IsKeyPressed(KEY_P))
{
isSimulating = !isSimulating;
}
if (IsKeyPressed(KEY_R))
{
InitWorld();
}
if (IsKeyPressed(KEY_Q))
{
SpawnEntity(
GetRandomValue(50, 950),
GetRandomValue(20, 150),
GetRandomValue(15, 45),
1.0f,
(Color)
{
GetRandomValue(50,255),
GetRandomValue(50,255),
GetRandomValue(50,255),
255
});
}
if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT))
{
Vector2 m = GetMousePosition();
SpawnEntity(
m.x,
m.y,
25,
1.0f,
ORANGE);
}
if (isSimulating)
{
UpdatePlayerControls();
UpdateEntities(dt, screenWidth);
simTime += dt;
}
BeginDrawing();
ClearBackground(RAYWHITE);
DrawLine(
0,
(int)ground_y,
screenWidth,
(int)ground_y,
DARKGRAY);
DrawText(
"GROUND",
10,
(int)ground_y + 5,
20,
DARKGRAY);
DrawEntities();
DrawRectangle(
0,
0,
screenWidth,
120,
Fade(LIGHTGRAY, 0.4f));
DrawText(
"WRLDBOX SANDBOX",
10,
10,
28,
BLACK);
DrawText(
TextFormat("Time: %.2f", simTime),
10,
45,
20,
BLACK);
DrawText(
TextFormat("Entities: %d",
CountEntities()),
10,
70,
20,
BLACK);
if (player)
{
DrawText(
TextFormat(
"Player Pos: %.1f %.1f",
player->position.x,
player->position.y),
250,
45,
20,
BLACK);
DrawText(
TextFormat(
"Player Vel: %.1f %.1f",
player->velocity.x,
player->velocity.y),
250,
70,
20,
BLACK);
}
DrawText(
isSimulating ?
"SIMULATING" :
"PAUSED",
850,
15,
25,
isSimulating ?
GREEN :
RED);
DrawText("A/D = Move", 700, 45, 18, BLACK);
DrawText("SPACE = Jump", 700, 65, 18, BLACK);
DrawText("LMB = Spawn Cube", 700, 85, 18, BLACK);
DrawText("Q = Random Cube", 700, 105, 18, BLACK);
DrawText("P = Pause | R = Reset", 700, 125, 18, BLACK);
EndDrawing();
}
CloseWindow();
return 0;
}

115
src/physics.c Normal file
View File

@@ -0,0 +1,115 @@
#include <math.h>
#include "physics.h"
#include "world.h"
#include "config.h"
void UpdateEntities(float dt, int screenWidth)
{
for (int i = 0; i < MAX_ENTITIES; i++)
{
Entity *e = &entities[i];
if (!e->active)
continue;
bool onGround = IsGrounded(e);
if (e->affectedByGravity)
{
ApplyForce(
e,
(Vector2){0, e->mass * g}
);
}
e->acceleration.x =
e->force.x / e->mass;
e->acceleration.y =
e->force.y / e->mass;
e->velocity.x +=
e->acceleration.x * dt;
e->velocity.y +=
e->acceleration.y * dt;
e->velocity.x *= AIR_DRAG;
e->velocity.y *= AIR_DRAG;
if (onGround)
{
if (e->velocity.x > 0)
{
e->velocity.x -=
GROUND_FRICTION * dt;
if (e->velocity.x < 0)
e->velocity.x = 0;
}
else if (e->velocity.x < 0)
{
e->velocity.x +=
GROUND_FRICTION * dt;
if (e->velocity.x > 0)
e->velocity.x = 0;
}
}
if (e->isPlayer)
{
if (e->velocity.x > MAX_PLAYER_SPEED)
e->velocity.x = MAX_PLAYER_SPEED;
if (e->velocity.x < -MAX_PLAYER_SPEED)
e->velocity.x = -MAX_PLAYER_SPEED;
}
e->position.x +=
e->velocity.x * dt;
e->position.y +=
e->velocity.y * dt;
e->force = (Vector2){0, 0};
if (e->position.y +
e->size * 0.5f >=
ground_y)
{
e->position.y =
ground_y -
e->size * 0.5f;
e->velocity.y *=
-BOUNCE;
if (fabsf(e->velocity.y) < 15.0f)
{
e->velocity.y = 0;
}
}
if (e->position.x -
e->size * 0.5f < 0)
{
e->position.x =
e->size * 0.5f;
e->velocity.x *= -0.6f;
}
if (e->position.x +
e->size * 0.5f >
screenWidth)
{
e->position.x =
screenWidth -
e->size * 0.5f;
e->velocity.x *= -0.6f;
}
}
}

6
src/physics.h Normal file
View File

@@ -0,0 +1,6 @@
#ifndef PHYSICS_H
#define PHYSICS_H
void UpdateEntities(float dt, int screenWidth);
#endif

39
src/player.c Normal file
View File

@@ -0,0 +1,39 @@
#include "player.h"
#include "world.h"
#include "config.h"
#include "raylib.h"
void UpdatePlayerControls(void)
{
if (!player)
return;
if (IsKeyDown(KEY_A))
{
ApplyForce(
player,
(Vector2){-PLAYER_FORCE, 0}
);
}
if (IsKeyDown(KEY_D))
{
ApplyForce(
player,
(Vector2){PLAYER_FORCE, 0}
);
}
if (IsGrounded(player) &&
IsKeyPressed(KEY_SPACE))
{
player->velocity.y = 0;
ApplyForce(
player,
(Vector2){0, -JUMP_FORCE}
);
}
}

6
src/player.h Normal file
View File

@@ -0,0 +1,6 @@
#ifndef PLAYER_H
#define PLAYER_H
void UpdatePlayerControls(void);
#endif

38
src/render.c Normal file
View File

@@ -0,0 +1,38 @@
#include "render.h"
#include "world.h"
#include "raylib.h"
void DrawEntities(void)
{
for (int i = 0; i < MAX_ENTITIES; i++)
{
Entity *e = &entities[i];
if (!e->active)
continue;
Rectangle rect =
{
e->position.x - e->size * 0.5f,
e->position.y - e->size * 0.5f,
e->size,
e->size
};
DrawRectangleRec(rect, e->color);
DrawRectangleLinesEx(rect, 2, BLACK);
Vector2 velEnd =
{
e->position.x + e->velocity.x * 0.10f,
e->position.y + e->velocity.y * 0.10f
};
DrawLineEx(
e->position,
velEnd,
2,
DARKBLUE);
}
}

6
src/render.h Normal file
View File

@@ -0,0 +1,6 @@
#ifndef RENDER_H
#define RENDER_H
void DrawEntities(void);
#endif

133
src/world.c Normal file
View File

@@ -0,0 +1,133 @@
#include <stddef.h>
#include "world.h"
const float scale = 43.7445319335f;
const float g = 9.81f * scale;
const float PLAYER_FORCE = 3500.0f;
const float JUMP_FORCE = 22000.0f;
const float AIR_DRAG = 0.999f;
const float GROUND_FRICTION = 1200.0f;
const float MAX_PLAYER_SPEED = 300.0f;
const float BOUNCE = 0.45f;
const float ground_y = 550.0f;
Entity entities[MAX_ENTITIES];
Entity *player = NULL;
bool isSimulating = true;
float simTime = 0.0f;
void ApplyForce(Entity *e, Vector2 force)
{
if (!e || !e->active)
return;
e->force.x += force.x;
e->force.y += force.y;
}
bool IsGrounded(Entity *e)
{
if (!e)
return false;
return (
e->position.y +
e->size * 0.5f >=
ground_y - 2.0f
);
}
Entity *SpawnEntity(
float x,
float y,
float size,
float mass,
Color color)
{
for (int i = 0; i < MAX_ENTITIES; i++)
{
if (!entities[i].active)
{
Entity *e = &entities[i];
e->active = true;
e->isPlayer = false;
e->affectedByGravity = true;
e->mass = mass;
e->size = size;
e->position = (Vector2){x, y};
e->velocity = (Vector2){0, 0};
e->acceleration = (Vector2){0, 0};
e->force = (Vector2){0, 0};
e->color = color;
return e;
}
}
return NULL;
}
void ClearWorld(void)
{
for (int i = 0; i < MAX_ENTITIES; i++)
{
entities[i].active = false;
}
player = NULL;
}
void InitWorld(void)
{
ClearWorld();
player = SpawnEntity(
120,
120,
40,
1.0f,
BLUE);
if (player)
{
player->isPlayer = true;
}
for (int i = 0; i < 8; i++)
{
SpawnEntity(
300 + i * 50,
50,
25,
1.0f,
RED);
}
simTime = 0.0f;
}
int CountEntities(void)
{
int count = 0;
for (int i = 0; i < MAX_ENTITIES; i++)
{
if (entities[i].active)
count++;
}
return count;
}

30
src/world.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef WORLD_H
#define WORLD_H
#include "entity.h"
#include "config.h"
extern Entity entities[MAX_ENTITIES];
extern Entity *player;
extern bool isSimulating;
extern float simTime;
void ApplyForce(Entity *e, Vector2 force);
bool IsGrounded(Entity *e);
Entity *SpawnEntity(
float x,
float y,
float size,
float mass,
Color color);
void ClearWorld(void);
void InitWorld(void);
int CountEntities(void);
#endif