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

very bad collision(work in progress)

Browse Source
This commit is contained in:
swim67667
2026-06-22 01:29:58 -04:00
commit 22377c6f1a
26 changed files with 4453 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
.vscode/

23
Makefile Normal file
View File

@@ -0,0 +1,23 @@
CC=gcc
SRC=src/main.c \
src/world.c \
src/player.c \
src/physics.c \
src/render.c \
src/collision.c\
OUT=wrldbox
INCLUDES=-Iinclude
LIBPATH=-Llib
CFLAGS=-O2 -Wall
LIBS=-lraylib -lX11 -ldl -lpthread -lm
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

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.

126
OLD/ray.c Normal file
View File

@@ -0,0 +1,126 @@
// ray.c A-0-i by team wholeworldcoding.
// working physics simulation with 1 object, limited playground and fixed parameters
// This is P7MJ, out.
// Changes:
// Reversing gravity makes it work?!!!
// Added scale factor, mathed the shit out of that.
#include <stdio.h>
#include <stdlib.h>
#include "raylib.h"
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_y = 100; // Starting Y (pixels)
float obj_vel_x = 50; // Velocity X (pixels/second)
float obj_vel_y = 0; // Velocity Y (pixels/second)
float ground_y = 550; // Ground at 550 pixels (assuming 600px screen height)
float time_step = 0.0f;
float rect_size = 40; // Size of the rectangle
int main(void) {
const int screenWidth = 800;
const int screenHeight = 600;
InitWindow(screenWidth, screenHeight, "WrldBox // ray.c");
SetTargetFPS(60); // 60 frames per second
float deltaTime = 0.0f;
bool isSimulating = true;
printf(">= SIMULATION PARAMETERS =<\n");
printf("g= %f\nX= %.2f Y= %.2f GROUND_Y= %.2f\nVEL_X= %.2f VEL_Y= %.2f\n\n",
g, obj_x, obj_y, ground_y, obj_vel_x, obj_vel_y);
while (!WindowShouldClose()) {
// Calculate delta time (time since last frame)
deltaTime = GetFrameTime();
// Control simulation with spacebar
if (IsKeyPressed(KEY_SPACE)) {
isSimulating = !isSimulating;
}
// Reset with R key
if (IsKeyPressed(KEY_R)) {
obj_x = 100;
obj_y = 100;
obj_vel_x = 50;
obj_vel_y = 0;
time_step = 0.0f;
isSimulating = true;
printf("\n>= SIMULATION RESET =<\n");
}
// Update physics if simulating and object is above ground
if (isSimulating && obj_y + rect_size/2 < ground_y) {
// Your original physics logic with deltaTime
obj_vel_y += deltaTime * g; // v = u + at
obj_y += obj_vel_y * deltaTime; // s = ut + 1/2 at^2 is handled by this
obj_x += obj_vel_x * deltaTime;
time_step += deltaTime;
// Real-time console output (optional)
if ((int)(time_step * 60) % 30 == 0) { // Print every ~0.5 seconds
printf("\r[%.2fs] X: %.2f Y: %.2f VEL_X: %.2f VEL_Y: %.2f",
time_step, obj_x, obj_y, obj_vel_x, obj_vel_y);
fflush(stdout);
}
}
// Clamp to ground (prevent going through)
if (obj_y + rect_size/2 >= ground_y) {
obj_y = ground_y - rect_size/2;
if (isSimulating) {
printf("\n\n>= Object Hit Ground =<\n");
printf("X: %.2f, Y: %.2f, VEL_X: %.2f, VEL_Y: %.2f TIME: %.2f\n",
obj_x, obj_y, obj_vel_x, obj_vel_y, time_step);
isSimulating = false;
}
}
// Keep rectangle in screen bounds horizontally
if (obj_x - rect_size/2 < 0) obj_x = rect_size/2;
if (obj_x + rect_size/2 > screenWidth) obj_x = screenWidth - rect_size/2;
// Drawing
BeginDrawing();
ClearBackground(RAYWHITE);
// Draw ground line
DrawLine(0, ground_y, screenWidth, ground_y, DARKGRAY);
// Draw ground label
DrawText("GROUND", 10, ground_y + 5, 20, DARKGRAY);
// Draw the falling rectangle
Rectangle rect = { obj_x - rect_size/2, obj_y - rect_size/2, rect_size, rect_size };
DrawRectangleRec(rect, RED);
DrawRectangleLinesEx(rect, 2, MAROON);
// Draw info text
DrawText(TextFormat("Time: %.2f s", time_step), 10, 10, 20, DARKGRAY);
DrawText(TextFormat("Position: (%.1f, %.1f)", obj_x, obj_y), 10, 35, 20, DARKGRAY);
DrawText(TextFormat("Velocity: (%.1f, %.1f)", obj_vel_x, obj_vel_y), 10, 60, 20, DARKGRAY);
DrawText(TextFormat("Status: %s", isSimulating ? "SIMULATING" : "PAUSED"), 10, 85, 20, isSimulating ? GREEN : RED);
// Draw controls help
DrawText("Controls:", screenWidth - 200, 10, 20, DARKGRAY);
DrawText("SPACE: Pause/Resume", screenWidth - 200, 35, 15, DARKGRAY);
DrawText("R: Reset", screenWidth - 200, 55, 15, DARKGRAY);
DrawText("ESC: Exit", screenWidth - 200, 75, 15, DARKGRAY);
// Draw velocity vector (optional visualization)
Vector2 velocityEnd = { obj_x + obj_vel_x * 0.1f, obj_y + obj_vel_y * 0.1f };
DrawLineEx((Vector2){obj_x, obj_y}, velocityEnd, 3, BLUE);
DrawText("Velocity Vector", obj_x + 5, obj_y - 10, 15, BLUE);
EndDrawing();
}
CloseWindow();
return 0;
}

4
OLD/structure.txt Normal file
View File

@@ -0,0 +1,4 @@
launcher.c
render.c
character.c
physics.c

38
OLD/text_physics.c Normal file
View File

@@ -0,0 +1,38 @@
#include <stdio.h>
#include <stdlib.h>
#ifdef _WIN32
#include <windows.h>
#define cross_sleep(ms) Sleep(ms) // Windows Sleep takes milliseconds
#else
#include <unistd.h>
#define cross_sleep(ms) usleep(ms * 1000) // POSIX usleep takes microseconds
#endif
const float g = -9.81;
float obj_x = 0;
float obj_y = 100;
float obj_vel_x = 3;
float obj_vel_y = 0;
float ground_y = 0;
float time = 0;
int main() {
printf(">= SIMULATION PARAMETERS =<\n");
printf("g= %f\nX= %f Y= %f GROUND_Y= %f\nVEL_X= %.f VEL_Y= %f\n\n", g, obj_x, obj_y, ground_y, obj_vel_x, obj_vel_y);
while (obj_y > ground_y){
// Add to the vel;
obj_vel_y += 0.001 * g;
// calculate change based on new vel
obj_y += obj_vel_y * 0.001;
obj_x += obj_vel_x * 0.001;
printf("\r[%.2fs] X: %.2f Y: %.2f VEL_X: %.2f VEL_Y: %.2f", time, obj_x, obj_y, obj_vel_x, obj_vel_y);
fflush(stdout);
cross_sleep(1);
time += 0.001;
}
printf("\n\n>= Object End Stats =<\n");
printf("X: %.2f, Y: %.2f, VEL_X: %.2f, VEL_Y: %.2f TIME: %f\n", obj_x, obj_y, obj_vel_x, obj_vel_y, time);
return 0;
}

30
README.md Normal file
View File

@@ -0,0 +1,30 @@
# WrldBox Engine
This project *is* the next major `wholeworldcoding` project.
## 🧊Introduction
**WrldBox** is a work-in-progress sandbox simulator made by Team wholeworldcoding. It is currently in a pretty developed experimental stage.
It consists of several components:
- `src/main.c`, Main script. Takes all other src and actually renders the engine.
- `src/physics.c`, All the science & math crap. Ugh. (physics.h: exposes UpdateEntities function)
- `src/render.c`, Rendering of entities. Entities are currently limited to rectangles for... no particular reason. (render.h: exposes DrawEntities function)
- `src/player.c`, Player control scripting. (player.h: exposes UpdatePlayerControls function)
- More stuff in src. README in progress.
- OLD contains the original logic this came from.
## 🛠️ Build and Compile
Clone the repository. Once you have navigated to the folder, you can run:
- `make`
## 🏅Credits
This project was impossible without the support of all three `wholeworldcoding` members.
and Alex

1743
include/raylib.h Executable file
View File

File diff suppressed because it is too large Load Diff

BIN
lib/libraylib.a Executable file
View File

Binary file not shown.

48
src/collision.c Normal file
View File

@@ -0,0 +1,48 @@
#include "world.h"
#include <math.h>
#include "config.h"
#include "collision.h"
#include "player.h"
void checkCollision(){
float playerx=0.0;
float playery=0.0;
float plrsize=0.0;
for (int i = 0; i < MAX_ENTITIES; i++){
Entity *e = &entities[i];
if (!e->active)
continue;
if(e->isPlayer == false){
float objposx=e->position.x;
//float objposy=e->position.y;
float objsize=e->size;
if(playerx-(plrsize/2)<objposx+(objsize/2) && playerx-(plrsize/2)>objposx-(objsize/2)){
ApplyForce(
e,
(Vector2){10000, 1000}
);
if(dir){
ApplyForce(
player,
(Vector2){(curhorvel*3), 1000}
);
}
else{
ApplyForce(
player,
(Vector2){-(curhorvel*3), 1000}
);
}
}
}
else{
playerx=e->position.x;
playery=e->position.y;
if(playery==playery)
plrsize=e->size;
}
}
}

8
src/collision.h Normal file
View File

@@ -0,0 +1,8 @@
#ifndef COLLISION_H
#define COLLISION_H
// FUNction declaration! yay!!!
// run by main.c constantly to allow player input.
void checkCollision();
#endif

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

10
src/docprogress.txt Normal file
View File

@@ -0,0 +1,10 @@
main.c - Done
physics.c - Done, refine later
physics.h - Done
render.c - Done
render.h - Done
player.c - Done
player.h - Done
world.c
world.h
config.h

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

184
src/main.c Normal file
View File

@@ -0,0 +1,184 @@
#include <stdio.h>
// add all the shit from the other shit
#include "raylib.h"
#include "world.h"
#include "physics.h"
#include "player.h"
#include "render.h"
#include "config.h"
#include "collision.h"
int main(void)
{
// Let's make a window
const int screenWidth = 1000;
const int screenHeight = 600;
InitWindow(
screenWidth,
screenHeight,
"WrldBox Sandbox");
SetTargetFPS(60);
// Now we actually start the code
InitWorld();
printf("WrldBox engine started\n");
printf("Gravity = %.2f\n", g);
// until we close the window, expect inputs
while (!WindowShouldClose())
{
float dt = GetFrameTime();
if (IsKeyPressed(KEY_P))
{
// If it's simulating, stop simulating. If it isn't simulating, start simulating.
isSimulating = !isSimulating;
}
if (IsKeyPressed(KEY_R))
{
// VERY complicated reset logic
InitWorld();
}
if (IsKeyPressed(KEY_Q))
{
// We're gonna have to rewrite the entity logic at some point. Because an actual game doesn't just contain a bunch of blocks. But whatever for now...
// Q key pressed? -> Poof, box, random position, random size, random color.
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))
{
// Spawn cube where the mouse is when it clicks!
Vector2 m = GetMousePosition();
SpawnEntity(
m.x,
m.y,
25,
1.0f,
ORANGE);
}
if (isSimulating)
{
// allow player to be controlled, fit everything within the size of the screen
UpdatePlayerControls();
checkCollision();
UpdateEntities(dt, screenWidth);
simTime += dt;
}
// UI shenanigans
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();
}
// When the window wants to close, close it. What a surprise.
CloseWindow();
return 0;
}

132
src/physics.c Normal file
View File

@@ -0,0 +1,132 @@
#include <math.h>
// better hope you were paying attention in physics class for this one
#include "physics.h"
#include "world.h"
#include "config.h"
// Main physics update loop for all entities
void UpdateEntities(float dt, int screenWidth)
{
// Iterate through all possible entities
for (int i = 0; i < MAX_ENTITIES; i++)
{
Entity *e = &entities[i];
// Skip inactive entities
if (!e->active)
continue;
// Check if entity is currently touching the ground
// YOU'RE GROUNDED!!! lol
bool onGround = IsGrounded(e);
// Apply gravity force if enabled for this entity
if (e->affectedByGravity)
{
ApplyForce(
e,
(Vector2){0, e->mass * g}
);
}
// Compute acceleration from accumulated forces (F = ma)
e->acceleration.x =
e->force.x / e->mass;
e->acceleration.y =
e->force.y / e->mass;
// Integrate velocity from acceleration
e->velocity.x +=
e->acceleration.x * dt;
e->velocity.y +=
e->acceleration.y * dt;
// Apply air drag to slow movement over time
e->velocity.x *= AIR_DRAG;
e->velocity.y *= AIR_DRAG;
// Apply ground friction when on the ground
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;
}
}
// Clamp player horizontal speed
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;
}
// Integrate position from velocity
e->position.x +=
e->velocity.x * dt;
e->position.y +=
e->velocity.y * dt;
// Reset forces after integration step
e->force = (Vector2){0, 0};
// Ground collision
if (e->position.y +
e->size * 0.5f >=
ground_y)
{
e->position.y =
ground_y -
e->size * 0.5f;
e->velocity.y *=
-BOUNCE;
// Stop tiny bounces... or at least, attempt to.
if (fabsf(e->velocity.y) < 15.0f)
{
e->velocity.y = 0;
}
}
// Left wall collision
if (e->position.x -
e->size * 0.5f < 0)
{
e->position.x =
e->size * 0.5f;
e->velocity.x *= -0.6f;
}
// Right wall collision
if (e->position.x +
e->size * 0.5f >
screenWidth)
{
e->position.x =
screenWidth -
e->size * 0.5f;
e->velocity.x *= -0.6f;
}
}
}

9
src/physics.h Normal file
View File

@@ -0,0 +1,9 @@
#ifndef PHYSICS_H
#define PHYSICS_H
// FUNction declaration! yay!!!
// used by main script to update entities as time goes on
// i don't think it's used anywhere else, but double check me
void UpdateEntities(float dt, int screenWidth);
#endif

58
src/player.c Normal file
View File

@@ -0,0 +1,58 @@
#include "player.h"
#include "world.h"
#include "config.h"
#include "raylib.h"
// let's a go!
float curhorvel=0.0f; //current horizonatal velocity
bool dir=0;
void UpdatePlayerControls(void)
{
// if there isn't a player, you probably can't do much
if (!player){
return;
}
if(curhorvel==0.0f){
curhorvel=65.5f*scale;
}
// if a key pressed, push player to the left
if (IsKeyDown(KEY_A))
{
dir=1;
if(curhorvel<MAX_PLAYER_SPEED){
curhorvel=curhorvel*PLAYER_SPEED_FACTOR;
}
ApplyForce(
player,
(Vector2){-curhorvel, 0}
);
}
// if d key pressed, push player to the right
else if (IsKeyDown(KEY_D))
{
dir=0;
if(curhorvel<=MAX_PLAYER_SPEED){
curhorvel=curhorvel*PLAYER_SPEED_FACTOR;
}
ApplyForce(
player,
(Vector2){curhorvel, 0}
);
}
else{
curhorvel=65.5f*scale;
}
// if sspace key pressed (and player isn't already jumping), push player
if (IsGrounded(player) &&
IsKeyPressed(KEY_SPACE))
{
player->velocity.y = 0;
ApplyForce(
player,
(Vector2){0, -JUMP_FORCE}
);
}
}

10
src/player.h Normal file
View File

@@ -0,0 +1,10 @@
#ifndef PLAYER_H
#define PLAYER_H
// FUNction declaration! yay!!!
// run by main.c constantly to allow player input.
extern bool dir;
extern float curhorvel;
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"
// Take entities, put em on the screen. Basic rendering file. Our entities are just rectangles, which we should lowkey fix... but uh... that's a problem for LATER...
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);
}
}

7
src/render.h Normal file
View File

@@ -0,0 +1,7 @@
#ifndef RENDER_H
#define RENDER_H
// FUNction declaration! yay!!!
// Make an entity! Once again, pretty sure this is must used in main.c
void DrawEntities(void);
#endif

139
src/world.c Normal file
View File

@@ -0,0 +1,139 @@
#include <stddef.h>
#include "world.h"
// the beeg one. hooooooooooooooooh boy
const float scale = 43.7445319335f;
const float g = 9.81f * scale;
const float PLAYER_SPEED_FACTOR =1.1f; //1.1 is good
const float JUMP_FORCE = 450.0f*scale;
const float AIR_DRAG = 0.999f;
const float GROUND_FRICTION = 27.432f*scale;
const float MAX_PLAYER_SPEED = 10.0f*scale;
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;
}
// say bye bye to EVERYTHINGGGG AHAHAHAHAHAAH
// im a little mad with power
// this is literally just a helper function to clear the entities and player
void ClearWorld(void)
{
for (int i = 0; i < MAX_ENTITIES; i++)
{
entities[i].active = false;
}
player = NULL;
}
// used in main.c to start the actual engine behaviors. spawns the player, and a few other boxes for funsies.
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;
}
// helper function: count number of entities. Something somewhere uses this. I think it's probably for entity counting. Don't quote me on that.
int CountEntities(void)
{
int count = 0;
for (int i = 0; i < MAX_ENTITIES; i++)
{
if (entities[i].active)
count++;
}
return count;
}

34
src/world.h Normal file
View File

@@ -0,0 +1,34 @@
#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;
extern const float MAX_PLAYER_SPEED;
extern const float PLAYER_SPEED_FACTOR;
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

BIN
wrldbox Executable file
View File

Binary file not shown.