milkwx3/CubeGame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c60f598661fe86270911a8e4cd84abbab6ca3a98
CubeGame/src/rcraft.cpp
T
milkwx3 c60f598661 First commit (very unfinished)
2026-06-13 22:02:49 +03:00

1604 lines
57 KiB
C++
Raw Blame History

#include "raylib.h"
#include "math.h"
#include "raymath.h"
#include <stdint.h>
#include <stdbool.h>
#include "common.hpp"
#include <stdio.h>
#include "rlgl.h"
#include <unordered_set>
#include <iostream>
#include <stack>
#include <cstring>
#include <algorithm>
#include <vector>
#include <list>
#include <climits>
#include <queue>
#include <thread>
#define MAX_RAY_DISTANCE 8.0f
struct MessageData {
std::string message;
float lifetime;
};
static inline int imax(int a, int b) {
if(a > b) { return a; }
return b;
}
extern std::vector<Item> registry;
void Debug_Write(const std::string &stuff);
Vector2 cameraMovementSmooth;
static float camYaw = 0.0f;
static float camPitch = -45.0f;
static const float acceleration = 48.0f;
static const float drag = 6.0f; // tuned for feel
Camera camera;
bool online = false;
bool flying = false;
unsigned long long worldTime;
static float entUpdateCounter;
int selectedBlockType = 1;
bool hide_ui = false;
bool taking_panorama = false;
int panorama_step;
Music currentMusic;
static float tilNextMusic;
Font fnt;
Texture2D terrain;
Texture2D water;
Texture2D white_pixel;
Entity* ent;
const bool ROTATE_PLAYER_WITH_CAMERA = true;
static Sound wood_place;
static Sound stone_place;
static Sound dirt_place;
static Sound grass_place;
bool tick_entities;
const std::string LocaleGet(std::string loc);
bool InputGetKeyDown(const std::string name);
bool InputGetKeyPressed(const std::string name);
extern std::list<Entity> entities;
std::bitset<WORLD_SIZE_BLOCKS*WORLD_SIZE_BLOCKS/8/8> clouds;
std::queue<Vector3I> tickedBlocks;
struct MeshUnit {
Model model;
int vertices;
};
struct ProfilerPart {
std::string id;
double time;
Color color;
};
std::vector<ProfilerPart> profParts;
static void AddProfilerPart(std::string id, double time, Color color) {
ProfilerPart part = {};
part.id = id;
part.time = time;
part.color = color;
profParts.push_back(part);
}
static Vector3 CameraForwardFromYawPitch(float yaw, float pitch)
{
Vector3 f;
f.x = cosf(pitch) * cosf(yaw);
f.y = sinf(pitch);
f.z = cosf(pitch) * sinf(yaw);
return Vector3Normalize(f);
}
Chunk world[MAX_WORLD_AREA];
static MeshUnit rendering[MAX_WORLD_AREA];
static MeshUnit renderingT[MAX_WORLD_AREA];
GameState state = GAME_STATE_MAINMENU;
bool loaderParam_remeshOnly = false;
int worldCreationProgress = 0;
int worldCreationStep = 0;
static bool IsBlockSolid(int bx, int by, int bz)
{
return GetBlock(world, bx, by, bz) != 0;
}
static bool IsBlockWater(int bx, int by, int bz)
{
return GetBlock(world, bx, by, bz) == BLOCK_WATERS;
}
typedef struct Plane {
float a, b, c, d;
} Plane;
typedef struct Frustum {
Plane planes[6];
} Frustum;
static Frustum ExtractFrustumPlanes(Camera camera, float aspect)
{
Frustum frustum;
// Get current Projection and View matrices from raylib
Matrix proj = MatrixPerspective(camera.fovy * DEG2RAD, aspect, 0.01f, 1000.0f);
Matrix view = MatrixLookAt(camera.position, camera.target, camera.up);
Matrix mat = MatrixMultiply(view, proj); // View-Projection Matrix
// Left Plane
frustum.planes[0] = (Plane){ mat.m3 + mat.m0, mat.m7 + mat.m4, mat.m11 + mat.m8, mat.m15 + mat.m12 };
// Right Plane
frustum.planes[1] = (Plane){ mat.m3 - mat.m0, mat.m7 - mat.m4, mat.m11 - mat.m8, mat.m15 - mat.m12 };
// Bottom Plane
frustum.planes[2] = (Plane){ mat.m3 + mat.m1, mat.m7 + mat.m5, mat.m11 + mat.m9, mat.m15 + mat.m13 };
// Top Plane
frustum.planes[3] = (Plane){ mat.m3 - mat.m1, mat.m7 - mat.m5, mat.m11 - mat.m9, mat.m15 - mat.m13 };
// Near Plane
frustum.planes[4] = (Plane){ mat.m3 + mat.m2, mat.m7 + mat.m6, mat.m11 + mat.m10, mat.m15 + mat.m14 };
// Far Plane
frustum.planes[5] = (Plane){ mat.m3 - mat.m2, mat.m7 - mat.m6, mat.m11 - mat.m10, mat.m15 - mat.m14 };
// Normalize planes
for (int i = 0; i < 6; i++) {
float length = sqrtf(frustum.planes[i].a * frustum.planes[i].a +
frustum.planes[i].b * frustum.planes[i].b +
frustum.planes[i].c * frustum.planes[i].c);
frustum.planes[i].a /= length;
frustum.planes[i].b /= length;
frustum.planes[i].c /= length;
frustum.planes[i].d /= length;
}
return frustum;
}
static bool IsBoxInFrustum(Frustum frustum, BoundingBox box)
{
for (int i = 0; i < 6; i++) {
// Find the positive vertex (farthest along the plane normal)
Vector3 p = box.min;
if (frustum.planes[i].a >= 0) p.x = box.max.x;
if (frustum.planes[i].b >= 0) p.y = box.max.y;
if (frustum.planes[i].c >= 0) p.z = box.max.z;
// Calculate dot product of plane equation
float dot = (frustum.planes[i].a * p.x) +
(frustum.planes[i].b * p.y) +
(frustum.planes[i].c * p.z) +
frustum.planes[i].d;
// If the positive vertex is behind the plane, the box is outside
if (dot < 0) return false;
}
return true;
}
static bool IsChunkInFrustum(Frustum frustum, Chunk chunk, int x, int y) {
float highestBlock = 0;
for (int i = 0; i < CHUNK_SIZE*CHUNK_SIZE; i++)
{
if(highestBlock < chunk.highestBlock[i]) highestBlock = chunk.highestBlock[i];
}
BoundingBox bb = {};
bb.min = (Vector3){x, 0, y};
bb.max = (Vector3){x+CHUNK_SIZE, highestBlock, y+CHUNK_SIZE};
return IsBoxInFrustum(frustum, bb);
}
static void ResolveCollisions(float dt)
{
float minY = player_position.y;
float maxY = player_position.y + PLAYER_HEIGHT;
int minX = floorf(player_position.x - PLAYER_RADIUS);
int maxX = floorf(player_position.x + PLAYER_RADIUS);
int minZ = floorf(player_position.z - PLAYER_RADIUS);
int maxZ = floorf(player_position.z + PLAYER_RADIUS);
int minB = floorf(minY);
int maxB = floorf(maxY);
for (int bx = minX; bx <= maxX; bx++)
{
for (int bz = minZ; bz <= maxZ; bz++)
{
for (int by = minB; by <= maxB; by++)
{
if (!IsBlockSolid(bx, by, bz)) continue;
if(IsBlockWater(bx, by, bz)) {
if(player_velocity.y < -5) {
player_velocity.y = -5;
}
if(player_velocity.y > 5) {
player_velocity.y = 5;
}
continue;
}
player_velocity.x *= fmaxf(0.0f, 1.0f - drag * dt);
player_velocity.z *= fmaxf(0.0f, 1.0f - drag * dt);
float bx0 = (float)bx;
float by0 = (float)by;
float bz0 = (float)bz;
float bx1 = bx0 + 1.0f;
float by1 = by0 + 1.0f;
float bz1 = bz0 + 1.0f;
float px0 = player_position.x - PLAYER_RADIUS;
float py0 = player_position.y;
float pz0 = player_position.z - PLAYER_RADIUS;
float px1 = player_position.x + PLAYER_RADIUS;
float py1 = player_position.y + PLAYER_HEIGHT;
float pz1 = player_position.z + PLAYER_RADIUS;
float ix = fminf(px1, bx1) - fmaxf(px0, bx0);
float iy = fminf(py1, by1) - fmaxf(py0, by0);
float iz = fminf(pz1, bz1) - fmaxf(pz0, bz0);
if (ix > 0 && iy > 0 && iz > 0)
{
// find smallest penetration axis and push out along it
if (ix < iy && ix < iz)
{
// push on X
if (player_position.x < bx0) player_position.x -= ix;
else player_position.x += ix;
player_velocity.x = 0;
}
else if (iy < ix && iy < iz)
{
// push on Y
if (player_position.y < by0) player_position.y -= iy;
else player_position.y += iy;
if (player_velocity.y > 0) player_velocity.y = 0;
else player_velocity.y = 0;
}
else
{
// push on Z
if (player_position.z < bz0) player_position.z -= iz;
else player_position.z += iz;
player_velocity.z = 0;
}
}
}
}
}
}
bool loadedChunks[MAX_WORLD_AREA] = { false };
bool dirtyChunks[MAX_WORLD_AREA] = { false };
void Debug_EndMeasure(const std::string &stuff);
void Debug_EndMeasureLoops(const std::string &stuff, int loops);
static void RemeshChunk(int x, int y) {
int idx = x + y * MAX_WORLD_SIZE;
if(loadedChunks[idx]) {
UnloadModel(renderingT[idx].model);
UnloadModel(rendering[idx].model);
}
Chunk chunk = world[idx];
RebuildOpaqueMask(&chunk);
MeshData renderDataOpq = GenerateChunkMesh(GenerateCRDOpaque(chunk, world), chunk, x, y, 0xFF);
MeshData renderDataTsl = GenerateChunkMesh(GenerateCRDTranslucent(chunk, world), chunk, x, y, 0xFF);
Model model = LoadModelFromMesh(GenChunkMesh(renderDataOpq));
model.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = terrain;
MeshUnit munit0;
munit0.model = model;
munit0.vertices += renderDataOpq.vertexCount;
rendering[idx] = munit0;
model = LoadModelFromMesh(GenChunkMesh(renderDataTsl));
model.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = terrain;
MeshUnit munit1;
munit1.model = model;
munit1.vertices += renderDataTsl.vertexCount;
renderingT[idx] = munit1;
loadedChunks[idx] = true;
}
static bool RaycastBlock(Vector3 origin, Vector3 dir, float maxDist, Vector3 *outBlock, Vector3 *outPrev)
{
float t = 0.0f;
Vector3 pos = origin;
Vector3 step = Vector3Scale(dir, 0.1f); // step resolution (smaller => more accurate)
Vector3 last = origin;
while (t < maxDist)
{
pos = Vector3Add(origin, Vector3Scale(dir, t));
int bx = floorf(pos.x);
int by = floorf(pos.y);
int bz = floorf(pos.z);
if (bx < 0 || by < 0 || bz < 0 || bx >= WORLD_SIZE_BLOCKS || by >= WORLD_HEIGHT || bz >= WORLD_SIZE_BLOCKS) { t += 0.1f; continue; }
if (IsBlockSolid(bx, by, bz) && !IsBlockWater(bx, by, bz))
{
// hit block at bx,by,bz; last is previous pos (empty)
if (outBlock) *outBlock = (Vector3){ (float)bx, (float)by, (float)bz };
if (outPrev) *outPrev = (Vector3){ (float)floorf(last.x), (float)floorf(last.y), (float)floorf(last.z) };
return true;
}
last = pos;
t += 0.1f;
}
return false;
}
static Entity* RaycastEntity(Vector3 origin, Vector3 dir, float maxDist)
{
float t = 0.0f;
Vector3 pos = origin;
Vector3 step = Vector3Scale(dir, 0.1f);
Vector3 last = origin;
while (t < maxDist)
{
pos = Vector3Add(origin, Vector3Scale(dir, t));
int bx = floorf(pos.x);
int by = floorf(pos.y);
int bz = floorf(pos.z);
if (bx < 0 || by < 0 || bz < 0 || bx >= WORLD_SIZE_BLOCKS || by >= WORLD_HEIGHT || bz >= WORLD_SIZE_BLOCKS) { t += 0.1f; continue; }
for(Entity &ent : entities) {
if(Vector3Distance(pos, ent.position) < 0.5f) {
return &ent;
}
}
last = pos;
t += 0.1f;
}
return nullptr;
}
static inline Vector3 BlockToWorldCenter(int bx, int by, int bz)
{
return (Vector3){ bx , by , bz };
}
static inline void RemeshChunkForBlock(int bx, int by, int bz)
{
int cx = bx / CHUNK_SIZE;
int cz = bz / CHUNK_SIZE;
if (cx >= 0 && cx < MAX_WORLD_SIZE && cz >= 0 && cz < MAX_WORLD_SIZE) RemeshChunk(cx, cz);
}
static void AddNekit() {
Entity temp = NewEntity();
temp.type = 2;
temp.health = 50;
temp.velocity = {0, 0, 0};
temp.position = player_position + (Vector3){0, 10, 0};
AddEntity(temp);
}
ENetPeer *peer;
ENetHost* client;
static std::stack<std::vector<uint8_t>> worldPacketStack;
static int fetchedChunks;
int plrId = -1;
static bool pauseMenuActive;
void _LoadWorld(const char* path) {
Debug_Write("Loading world");
LoadWorld(world, path);
Debug_Write("World loaded");
state = GAME_STATE_LOADING;
worldCreationProgress = 0;
worldCreationStep = 2;
}
void PlayRandomMusic() {
currentMusic = LoadMusicStream(Pathify((std::string("music/calm0")+std::to_string(GetRandomValue(1,3))+std::string(".ogg")).c_str()));
PlayMusicStream(currentMusic);
}
static int _blockPlacedC = 0;
void SetBlockNetwork(Chunk world[], int bx, int by, int bz, int t) {
float pitch = GetRandomValue(-100, 100) / 100.0f * 0.25f + 1.0f;
int sound = B_Stone;
tickedBlocks.push({bx, by, bz});
tickedBlocks.push({bx-1, by, bz});
tickedBlocks.push({bx+1, by, bz});
tickedBlocks.push({bx, by-1, bz});
tickedBlocks.push({bx, by+1, bz});
tickedBlocks.push({bx, by, bz-1});
tickedBlocks.push({bx, by, bz+1});
if(t != 0) {
sound = BLOCKS[t].type;
}
else {
int id = GetBlock(world, bx, by, bz);
BlockDef block = BLOCKS[id];
if(id != 0) {
sound = block.type;
for (int x = 0; x < 4; x++)
{
for (int z = 0; z < 4; z++)
{
for (int y = 0; y < 4; y++)
{
if(GetRandomValue(0, 100) < 25) {
Particle part = NewParticle({bx + x / 4.0f - 0.375f, by + y / 4.0f - 0.375f, bz + z / 4.0f - 0.375f});
part.data[0] = block.textureSide;
if(y == 3) {
part.data[0] = block.textureTop;
}
part.velocity = Vector3({(x <= 1) ? -1.0f : 1.0f, (y <= 1) ? -1.0f : 1.0f, (z <= 1) ? -1.0f : 1.0f}) * 1.5f;
AddParticle(part);
part.lifetime = GetRandomValue(0, 100);
}
}
}
}
}
else {
return;
}
}
switch (sound)
{
case B_Dirt:
MS_PlaySound(dirt_place, pitch, 1, (Vector3){bx, by, bz});
break;
case B_Grass:
MS_PlaySound(grass_place, pitch, 1, (Vector3){bx, by, bz});
break;
case B_Wood:
MS_PlaySound(wood_place, pitch, 1, (Vector3){bx, by, bz});
break;
default:
MS_PlaySound(stone_place, pitch, 1, (Vector3){bx, by, bz});
break;
}
if(online) {
char data[5];
data[0] = NET_ARG_BLOCKDELTA;
data[1] = (uint8_t)bx;
data[2] = (uint8_t)by;
data[3] = (uint8_t)bz;
data[4] = (uint8_t)t;
SendPacketR(peer, data, 5);
}
else {
SetBlock(world, bx, by, bz, t);
int cx = bx / CHUNK_SIZE;
int cz = bz / CHUNK_SIZE;
int lx = bx - cx * CHUNK_SIZE;
int lz = bz - cz * CHUNK_SIZE;
dirtyChunks[GetIndexWorld(cx, cz)] = true;
if (lx == 0) dirtyChunks[GetIndexWorld(cx - 1, cz)] = true;
if (lx == CHUNK_SIZE - 1) dirtyChunks[GetIndexWorld(cx + 1, cz)] = true;
if (lz == 0) dirtyChunks[GetIndexWorld(cx, cz - 1)] = true;
if (lz == CHUNK_SIZE - 1) dirtyChunks[GetIndexWorld(cx, cz + 1)] = true;
}
_blockPlacedC++;
}
static void TickAvailableBlocks() {
if(tickedBlocks.size() > 0) {
Vector3I pos = tickedBlocks.front();
if(CanTick(GetBlock(world, pos.x, pos.y, pos.z))) {
TickBlock(world, pos.x, pos.y, pos.z);
tickedBlocks.pop();
}
else {
tickedBlocks.pop();
TickAvailableBlocks();
}
}
}
static bool serverStarted;
int TryConnect(const char* hostname) {
client = StartClient();
if(client == NULL)
{
fprintf(stderr, "An error occurred while trying to create an ENet client host!\n");
return NET_ERROR_INTERNAL;
}
ENetAddress address;
ENetEvent event;
int s = enet_address_set_host (& address, hostname);
address.port = PORT;
peer = enet_host_connect(client, &address, 1, 0);
if (peer == NULL)
{
fprintf (stderr,
"No available peers for initiating an ENet connection.\n");
return NET_ERROR_NOTFOUND;
}
printf("Found a host\n");
while (!serverStarted)
{
if(!online) serverStarted = true;
}
if (enet_host_service (client, & event, 10000) && event.type == ENET_EVENT_TYPE_CONNECT){
puts ("Connection succeeded.");
char data[1];
data[0] = NET_ARG_REQWORLD;
SendPacketR(peer, data, 1); // Tell the server to send all chunks
online = true;
state = GAME_STATE_LOADING;
return 0;
}
else
{
enet_peer_reset (peer);
return NET_ERROR_FAILED;
}
return -1;
}
std::thread serverThread;
void ServerThread(bool& started) {
StartInternalServer(started);
while(true) {
ServerNetworkUpdate();
}
}
void InitSingleplayer() {
online = true;
serverThread = std::thread(ServerThread, std::ref(serverStarted));
int result = TryConnect("localhost");
if(result == NET_ERROR_FAILED) {
state = GAME_STATE_MAINMENU;
}
}
std::vector<MessageData> messages;
bool survival = false;
bool chatOpen = false;
float oxygen = 100;
float blockBreakProgress;
void TakeDamage(float amount) {
player_health -= amount;
}
int currentlyTickedChunk = 0;
Vector3 highlightBlock = {-1, -1, -1};
static void GameUpdate(Camera camera, float &time) {
if (player_position.y < 0 ||
player_position.x < 0 ||
player_position.z < 0 ||
player_position.z > WORLD_SIZE_BLOCKS ||
player_position.x > WORLD_SIZE_BLOCKS) {
player_position = { MAX_WORLD_SIZE / 2 * CHUNK_SIZE, 128.0f, MAX_WORLD_SIZE / 2 * CHUNK_SIZE };
player_velocity = { 0 };
}
bool highlightValid = false;
float dt = GetFrameTime();
if (dt <= 0) dt = DELTA_SMOOTH;
if (dt > 0.1f) dt = 0.1f;
time += dt;
Vector3 forward = Vector3Normalize({ cosf(camYaw), 0.0f, sinf(camYaw) });
Vector3 right = Vector3Normalize(Vector3CrossProduct(forward, camera.up));
camera.position = (Vector3){ player_position.x - 0.5f, player_position.y + 1.25f, player_position.z - 0.5f};
camera.target = Vector3Add(camera.position, CameraForwardFromYawPitch(camYaw, camPitch));
camera.up = (Vector3){0,1,0};
float dt_faux = dt / 4.0f;
if(IsKeyPressed(KEY_ESCAPE)) {
if(chatOpen) chatOpen = false;
else if (inventoryOpen) CloseInventory();
else {
pauseMenuActive = !pauseMenuActive;
if(!pauseMenuActive) {
DisableCursor();
}
else {
EnableCursor();
}
}
}
/*if(IsKeyPressed(KEY_F2)) {
taking_panorama = true;
panorama_step = -1;
}
if(taking_panorama) {
if(panorama_step == 6) {
taking_panorama = false;
}
else {
camYaw = (90 * panorama_step) * DEG2RAD;
if(panorama_step < 3) {
camPitch = 0;
}
else {
camPitch = 89.99f * DEG2RAD;
if(panorama_step == 4) {
camPitch = -89.99f * DEG2RAD;
}
camYaw = 0;
}
}
}*/
if(InputGetKeyPressed("chat") && !pauseMenuActive) {
chatOpen = !chatOpen;
if(!chatOpen) {
DisableCursor();
}
else {
EnableCursor();
}
}
for (int _ = 0; _ < 4; _++)
{
player_position.x += player_velocity.x * dt_faux;
player_position.y += player_velocity.y * dt_faux;
player_position.z += player_velocity.z * dt_faux;
if(!flying) {
player_velocity.y -= GRAVITY * dt_faux;
}
ResolveCollisions(dt_faux);
}
if(!pauseMenuActive && !chatOpen && !inventoryOpen) {
float speedMod = 1;
if(InputGetKeyPressed("fly")) {
flying = !flying;
}
Vector3 wish = {0,0,0};
Vector2 walkAxis = InputGetWalkAxis();
wish = Vector3Add(Vector3Scale(forward, walkAxis.y),
Vector3Scale(right, walkAxis.x));
float inputMag = Vector3Length((Vector3){wish.x, 0, wish.z});
Vector3 wishDir = (inputMag > 0.0001f) ? Vector3Scale(wish, 1.0f / inputMag)
: (Vector3){0,0,0};
if (flying) {
speedMod = InputGetKeyDown("speed_up") ? 6.0f : 3.0f;
float w_y = 0;
if (InputGetKeyDown("jump")) w_y += 1.0f;
if (InputGetKeyDown("shift")) w_y -= 1.0f;
player_velocity.y = w_y * MOVE_SPEED * speedMod;
}
if (inputMag > 0.0001f) {
player_velocity.x += wishDir.x * acceleration * inputMag * speedMod * dt;
player_velocity.z += wishDir.z * acceleration * inputMag * speedMod * dt;
}
float hSpeed = sqrtf(player_velocity.x*player_velocity.x + player_velocity.z*player_velocity.z);
float maxH = MOVE_SPEED * speedMod;
if (hSpeed > maxH) {
float s = maxH / hSpeed;
player_velocity.x *= s;
player_velocity.z *= s;
}
if(!flying) {
bool onGround = false;
int belowY = floorf(player_position.y - 0.05f);
for (int bx = floorf(player_position.x - PLAYER_RADIUS); bx <= floorf(player_position.x + PLAYER_RADIUS); bx++)
for (int bz = floorf(player_position.z - PLAYER_RADIUS); bz <= floorf(player_position.z + PLAYER_RADIUS); bz++)
if (IsBlockSolid(bx, belowY, bz) && !IsBlockWater(bx, belowY, bz)) onGround = true;
if (InputGetKeyPressed("jump") && onGround) player_velocity.y = JUMP_SPEED;
if (InputGetKeyDown("jump") && IsBlockWater(player_position.x, player_position.y, player_position.z)) player_velocity.y += dt * 30;
}
Vector2 md = InputGetLookAxis();
camYaw += md.x * MOUSE_SENS;
camPitch -= md.y * MOUSE_SENS;
cameraMovementSmooth += md * dt / 8.0f;
cameraMovementSmooth -= cameraMovementSmooth * dt * 16.0f;
if (camPitch < PITCH_MIN && !taking_panorama) camPitch = PITCH_MIN;
if (camPitch > PITCH_MAX && !taking_panorama) camPitch = PITCH_MAX;
Vector3 camForward = CameraForwardFromYawPitch(camYaw, camPitch);
Vector3 rayOrigin = (Vector3){ player_position.x, player_position.y + 1.7f, player_position.z};;
Vector3 hitBlock, prevBlock;
if(IsKeyDown(KEY_N) && !online) {
AddNekit();
}
if(IsKeyPressed(KEY_F10)) {
tick_entities = !tick_entities;
}
if(IsKeyPressed(KEY_B) && !online) {
Entity temp = NewEntity();
temp.type = 3;
temp.position = camera.position;
temp.velocity = (camera.target - camera.position) * 4.0f;
AddEntity(temp);
}
if (RaycastBlock(rayOrigin, Vector3Normalize(camForward), 5, &hitBlock, &prevBlock))
{
if((int)hitBlock.x != (int)highlightBlock.x || (int)hitBlock.y != (int)highlightBlock.y || (int)hitBlock.z != (int)highlightBlock.z)
blockBreakProgress = 0.0f;
highlightBlock = hitBlock;
highlightValid = true;
}
else
{
blockBreakProgress = 0.0f;
highlightValid = false;
}
if (InputGetLMBDown())
{
player_attack_time += dt * 2;
if(player_attack_time > 1) {
player_attack_time = 0;
}
if(highlightValid) {
int bx = (int)highlightBlock.x;
int by = (int)highlightBlock.y;
int bz = (int)highlightBlock.z;
float speed = 1.0f;
int tier = 0;
Item* selected_item = HotbarGetSelected().item;
if(selected_item != nullptr) {
if(selected_item->type == IType_Mining) {
speed += selected_item->tier;
tier = selected_item->tier;
}
}
BlockDef block = BLOCKS[GetBlock(world, bx, by, bz)];
float hardnessMultiplier = block.hardness / 4.0f;
if(player_break_parts_time >= 0.05f) {
Vector3 v = {0, 1, 0};
int side = GetRandomValue(0, 3);
switch (side)
{
case 1:
v = {1, GetRandomValue(0, 15) / 16.0f, GetRandomValue(0, 15) / 16.0f};
break;
case 2:
v = {GetRandomValue(0, 15) / 16.0f, GetRandomValue(0, 15) / 16.0f, 1};
break;
default:
v = {GetRandomValue(0, 15) / 16.0f, 1, GetRandomValue(0, 15) / 16.0f};
break;
}
Particle part = NewParticle({bx + v.x - 0.375f, by + v.y - 0.375f, bz + v.z - 0.375f});
part.data[0] = block.textureSide;
part.velocity = {0};
AddParticle(part);
part.lifetime = GetRandomValue(0, 100);
player_break_parts_time = 0;
}
player_break_parts_time += dt;
if(block.min_tier <= tier)
blockBreakProgress+=dt*speed/hardnessMultiplier;
if(blockBreakProgress > 1.0f) {
HotbarAddItem(&registry[0], GetBlock(world, bx, by, bz));
SetBlockNetwork(world, bx, by, bz, 0);
blockBreakProgress = 0.0f;
}
}
}
else {
player_attack_time += (0.5f - player_attack_time) * dt * 16.0f;
blockBreakProgress = 0.0f;
}
if (InputGetLMB())
{
Entity* ent = RaycastEntity(rayOrigin, Vector3Normalize(camForward), 5);
int tier = 0;
Item* selected_item = HotbarGetSelected().item;
if(selected_item != nullptr) {
if(selected_item->type == IType_Weapon) {
tier = selected_item->tier;
}
}
if(ent != nullptr) {
ent->health -= 5.0f + tier * 5;
ent->damage_flash = 50;
ent->velocity += (camera.target - camera.position) * 50;
}
}
if (InputGetRMB())
{
InventoryItem selected = HotbarGetSelected();
if(selected.item != nullptr) {
std::cout << selected.item->type << std::endl;
switch (selected.item->type)
{
case IType_Edible:
HotbarRemoveSelected();
player_health += 10.0f;
break;
case IType_Block:
if(highlightValid) {
int px, py, pz;
px = (int)prevBlock.x;
py = (int)prevBlock.y;
pz = (int)prevBlock.z;
if (px >= 0 && py >= 0 && pz >= 0 && px < WORLD_SIZE_BLOCKS && py < WORLD_HEIGHT && pz < WORLD_SIZE_BLOCKS)
{
if (!(abs(px - player_position.x + 0.5f) < PLAYER_RADIUS * 2 && abs(pz - player_position.z + 0.5f) < PLAYER_RADIUS * 2 && abs(py - player_position.y) < PLAYER_HEIGHT - 0.2f))
{
SetBlockNetwork(world, px, py, pz, selected.damage);
HotbarRemoveSelected();
player_place_time = 1.0f;
}
}
}
break;
default:
break;
}
}
}
if(player_place_time > 0) {
player_place_time -= dt * 3.0f;
}
if(player_place_time < 0) {
player_place_time = 0;
}
float y = GetMouseWheelMove();
bool changed = abs(y) > 0.5f;
if(y > 0.5f) {
selectedBlockType++;
}
if(y < -0.5f) {
selectedBlockType--;
}
if(selectedBlockType > MAX_BLOCK_ID) {
selectedBlockType = 1;
}
if(selectedBlockType < 1) {
selectedBlockType = MAX_BLOCK_ID;
}
}
int bestIdx = -1;
int bestDist2 = INT_MAX;
int c = 0;
for (bool l : loadedChunks) {
int x, y;
GetXZFromIndex(c, &x, &y);
int dx = x - ((int)(player_position.x) >> 4);
int dy = y - ((int)(player_position.z) >> 4);
int dist2 = dx*dx + dy*dy;
if (dist2 > RENDER_DISTANCE_SQUARED) {
loadedChunks[c] = false;
}
else {
loadedChunks[c] = true;
}
c++;
}
c = 0;
for (bool b : dirtyChunks) {
if(b) {
int x, y;
GetXZFromIndex(c, &x, &y);
int dx = x - ((int)(player_position.x) >> 4);
int dy = y - ((int)(player_position.z) >> 4);
int dist2 = dx*dx + dy*dy;
if (dist2 <= RENDER_DISTANCE_SQUARED && dist2 < bestDist2) {
bestDist2 = dist2;
bestIdx = c;
}
}
c++;
}
double PROFCOUNT = GetTime();
if (bestIdx != -1) {
RebuildOpaqueMask(&world[bestIdx]);
int bx, by;
GetXZFromIndex(bestIdx, &bx, &by);
RemeshChunk(bx, by);
dirtyChunks[bestIdx] = false;
}
AddProfilerPart("rebuild", GetTime()-PROFCOUNT, BLUE);
PROFCOUNT = GetTime();
if(tick_entities) {
entUpdateCounter += dt;
if(entUpdateCounter > TPS_DIV) {
while (entUpdateCounter > 0)
{
UpdateEntities(world, TPS_DIV / 2.0f);
entUpdateCounter-= TPS_DIV;
}
TickAvailableBlocks();
entUpdateCounter = 0.0f;
}
}
AddProfilerPart("entities", GetTime()-PROFCOUNT, MAGENTA);
PROFCOUNT = GetTime();
ParticlesUpdate(dt, world);
AddProfilerPart("particles", GetTime()-PROFCOUNT, ORANGE);
MS_Update(dt, camera);
UpdateMusicStream(currentMusic);
std::stack<std::string> messages_local;
for(MessageData &msg : messages) {
if(msg.lifetime < 10.0f) {
messages_local.push(msg.message);
}
msg.lifetime += dt;
}
UpdateCamera(&camera, CAMERA_CUSTOM);
unsigned int debug_verts_opaque = 0;
unsigned int debug_verts_transparent = 0;
UpdateHotbar();
Frustum frustum = ExtractFrustumPlanes(camera, (float)GetScreenWidth() / (float)GetScreenHeight());
BeginDrawing();
ClearBackground(RAYWHITE);
DrawRectangle(0, 0, GetScreenWidth(), GetScreenHeight(), BLUE);
BeginMode3D(camera);
PROFCOUNT = GetTime();
double chunkRenderTime = 0;
for (int x = 0; x < MAX_WORLD_SIZE * MAX_WORLD_SIZE; x++)
{
int _x, _z;
GetXZFromIndex(x, &_x, &_z);
_x *= CHUNK_SIZE;
_z *= CHUNK_SIZE;
if(!loadedChunks[x]) continue;
if(!IsChunkInFrustum(frustum, world[x], _x, _z)) continue;
DrawModel(rendering[x].model, {0, 0, 0}, 1, WHITE);
debug_verts_opaque += rendering[x].vertices;
}
AddProfilerPart("chunk render opq", GetTime()-PROFCOUNT, MAROON);
DrawEntities(dt);
ParticlesDraw();
//Transparent shit
rlDisableDepthMask();
rlBegin(RL_QUADS);
rlSetTexture(white_pixel.id);
const int cloudMapLength = WORLD_SIZE_BLOCKS/8;
PROFCOUNT = GetTime();
for (int x = 0; x < cloudMapLength; x++)
{
for (int z = 0; z < cloudMapLength; z++)
{
rlColor4f(255, 255, 255, 255);
if(clouds.test(x * cloudMapLength + z)) { //TODO: Normal frustum culling
Vector3 A = Vector3Normalize((Vector3){x*8, 70, z*8}-(Vector3){camera.position.x, camera.position.y, camera.position.z});
float dot = Vector3DotProduct(A, camera.target - camera.position);
if(dot > cosf(FOV*DEG2RAD)) {
int ex_x = (imax(-x*8, 0) + imax(x*8-WORLD_SIZE_BLOCKS, 0)) >> 5;
int ex_z = (imax(-z*8, 0) + imax(z*8-WORLD_SIZE_BLOCKS, 0)) >> 5;
rlVertex3f(x*8, 70, z*8);
rlVertex3f(x*8+8, 70, z*8);
rlVertex3f(x*8+8, 70, z*8+8);
rlVertex3f(x*8, 70, z*8+8);
}
}
}
}
rlSetTexture(water.id);
for (int x = -8; x < MAX_WORLD_SIZE+8; x++)
{
for (int z = -8; z < MAX_WORLD_SIZE+8; z++)
{
if((x < 0 || x >= MAX_WORLD_SIZE) || (z < 0 || z >= MAX_WORLD_SIZE)) {
Vector3 A = Vector3Normalize((Vector3){x * CHUNK_SIZE, 32, z * CHUNK_SIZE}-(Vector3){camera.position.x, camera.position.y, camera.position.z});
float dot = Vector3DotProduct(A, camera.target - camera.position);
if(dot > cosf(FOV*DEG2RAD)) {
Vector3 A = Vector3Normalize((Vector3){x, 70, z}-(Vector3){camera.position.x, camera.position.y, camera.position.z});
float dot = Vector3DotProduct(A, camera.target - camera.position);
int ex_x = (imax(-x, 0) + imax(x-MAX_WORLD_SIZE, 0));
int ex_z = (imax(-z, 0) + imax(z-MAX_WORLD_SIZE, 0));
rlColor4ub(255, 255, 255, 255); //(255 >> ex_x) >> ex_z
rlTexCoord2f(0, CHUNK_SIZE);rlVertex3f(x*CHUNK_SIZE - 0.5f, 32 + 0.5f, (z+1)*CHUNK_SIZE - 0.5f);
rlTexCoord2f(CHUNK_SIZE, CHUNK_SIZE);rlVertex3f((x+1)*CHUNK_SIZE - 0.5f, 32 + 0.5f, (z+1)*CHUNK_SIZE - 0.5f);
rlTexCoord2f(CHUNK_SIZE, 0);rlVertex3f((x+1)*CHUNK_SIZE - 0.5f, 32 + 0.5f, z*CHUNK_SIZE - 0.5f);
rlTexCoord2f(0, 0);rlVertex3f(x*CHUNK_SIZE - 0.5f, 32 + 0.5f, z*CHUNK_SIZE - 0.5f);
}
}
}
}
rlEnd();
rlEnableDepthMask();
AddProfilerPart("fancy", GetTime()-PROFCOUNT, BLACK);
PROFCOUNT = GetTime();
std::vector<std::pair<float,int>> distances;
distances.reserve(MAX_WORLD_SIZE * MAX_WORLD_SIZE);
for (int i = 0; i < MAX_WORLD_SIZE * MAX_WORLD_SIZE; ++i) {
if (!loadedChunks[i]) continue;
int cx, cz;
GetXZFromIndex(i, &cx, &cz);
if (!IsChunkInFrustum(frustum, world[i], cx*CHUNK_SIZE, cz*CHUNK_SIZE)) continue;
float wx = cx * CHUNK_SIZE + CHUNK_SIZE * 0.5f;
float wz = cz * CHUNK_SIZE + CHUNK_SIZE * 0.5f;
float dx = wx - camera.position.x;
float dz = wz - camera.position.y;
float dist2 = dx*dx + dz*dz;
distances.emplace_back(dist2, i);
}
std::sort(distances.begin(), distances.end(),
[](auto &a, auto &b){ return a.first > b.first; });
for (auto &p : distances) {
int idx = p.second;
DrawModel(renderingT[idx].model, {0, 0, 0}, 1.0f, WHITE);
debug_verts_transparent += renderingT[idx].vertices;
}
AddProfilerPart("chunk render tsl", GetTime()-PROFCOUNT, RED);
if (highlightValid)
{
Vector3 center = BlockToWorldCenter((int)highlightBlock.x, (int)highlightBlock.y, (int)highlightBlock.z);
DrawCubeWires(center, 1.01f, 1.01f, 1.01f, BLACK);
DrawCube(center, 1.01f, 1.01f, 1.01f, Fade(WHITE, blockBreakProgress * 0.6f));
}
EndMode3D();
Vector3 camPos = camera.position;
Vector3 camTarget = camera.target;
camera.position = {0, 0, 0};
camera.target = {-cameraMovementSmooth.x, -cameraMovementSmooth.y, 1};
BeginMode3D(camera);
rlDisableDepthMask();
rlDisableDepthTest();
DrawSelectedItem();
rlEnableDepthTest();
rlEnableDepthMask();
EndMode3D();
camera.position = camPos;
camera.target = camTarget;
if(IsBlockWater(camera.position.x, camera.position.y+0.5f, camera.position.z)) {
oxygen -= dt * 10.0f;
DrawTexturePro(water, {0, 0, 16, 16}, {0, 0, (float)GetScreenWidth(), (float)GetScreenHeight()}, {0, 0}, 0, WHITE);
}
else {
oxygen += dt * 20.0f;
oxygen = Clamp(oxygen, 0, MAX_HP);
}
if(!hide_ui && !taking_panorama) {
char text[128];
sprintf(text, "%s %s", GAME_NAME, GAME_VERSION);
DrawTextB(text, 20, 20, DEFAULT_FONT_SIZE, WHITE);
sprintf(text, "%.0f FPS", 1 / dt);
DrawTextB(text, 20, 40, DEFAULT_FONT_SIZE, WHITE);
sprintf(text, "Player %d %.1f %.1f %.1f", plrId, player_position.x, player_position.y, player_position.z);
DrawTextB(text, 20, 60, DEFAULT_FONT_SIZE, WHITE);
MemInfo m;
Debug_GetProcessMemory(m);
float residentmem = m.resident / 1024.0f / 1024.0f;
float virtualmem = m.virtualSize / 1024.0f / 1024.0f;
sprintf(text, "Mem %.2fMiB/%.2fMiB", residentmem, virtualmem);
DrawTextB(text, 20, 80, DEFAULT_FONT_SIZE, WHITE);
sprintf(text, "Drawing %d verts", debug_verts_opaque+debug_verts_transparent);
DrawTextB(text, 120, 40, DEFAULT_FONT_SIZE, WHITE);
DrawRectangle(GetScreenWidth()/2-3, GetScreenHeight()/2-3, 6, 6, BLACK);
DrawRectangle(GetScreenWidth()/2-2, GetScreenHeight()/2-2, 4, 4, WHITE);
int idx = 0;
while (messages_local.size() > 0)
{
std::string msg = messages_local.top();
DrawTextB(msg.c_str(), 24, 96 + idx * 24, DEFAULT_FONT_SIZE, WHITE);
idx++;
messages_local.pop();
}
DrawRectangle(4-1, GetScreenHeight()-13, 2*(MAX_HP+2), 12, BLACK);
DrawRectangle(4+1, GetScreenHeight()-11, 2*player_health, 8, RED);
if(oxygen < MAX_HP) {
DrawRectangle(4-1, GetScreenHeight()-13-14, 2*(MAX_HP+2), 12, BLACK);
DrawRectangle(4+1, GetScreenHeight()-11-14, 2*oxygen, 8, BLUE);
}
DrawHotbar();
double totalTime = 0.0;
for (auto &p : profParts) totalTime += p.time;
if (totalTime <= 0.0) return;
float startAngle = -PI/2.0f;
const int segmentsPerSlice = 24;
const float cx = GetScreenWidth()-64;
const float cy = 64;
const float radius = 32;
for (auto &p : profParts) {
float frac = float(p.time / totalTime);
float sweep = frac * 2.0f * PI;
float endAngle = startAngle + sweep;
float angleA = startAngle;
for (int s = 1; s <= segmentsPerSlice; ++s) {
float angleB = startAngle + (s / (float)segmentsPerSlice) * sweep;
float x1 = cx;
float y1 = cy;
float x2 = cx + cosf(angleA) * radius;
float y2 = cy + sinf(angleA) * radius;
float x3 = cx + cosf(angleB) * radius;
float y3 = cy + sinf(angleB) * radius;
DrawTriangle({x3, y3}, {x2, y2}, {x1, y1}, p.color);
angleA = angleB;
}
/*float mid = (startAngle + endAngle) * 0.5f;
float lx = cx + cosf(mid) * (radius * 0.6f);
float ly = cy + sinf(mid) * (radius * 0.6f);
char label[128];
sprintf(label, "%s (%.1f ms)", p.id.c_str(), p.time * 1000.0f);
DrawText(label, lx - 20, ly - 6, 10, WHITE);*/
startAngle = endAngle;
}
int T = 0;
std::sort(profParts.begin(), profParts.end(),
[](auto &a, auto &b){ return a.time > b.time; });
for (auto &p : profParts) {
char label[128];
sprintf(label, "%s (%.1f ms) (%.1f%%)", p.id.c_str(), p.time * 1000.0f, p.time / totalTime*100);
DrawText(label, cx-radius-180+1, cy+T*8-radius+1, 8, BLACK);
DrawText(label, cx-radius-180, cy+T*8-radius, 8, p.color);
T++;
};
profParts.clear();
}
if(pauseMenuActive) {
DrawPauseMenu();
}
if(chatOpen) {
char* msg = DrawChat();
if(msg != nullptr) {
chatOpen = false;
DisableCursor();
char data[1+MAX_MESSAGE_LENGTH];
data[0] = NET_ARG_MESSAGEC;
memcpy(data+1, msg, MAX_MESSAGE_LENGTH);
SendPacketR(peer, data, 1+MAX_MESSAGE_LENGTH);
memset(msg, 0, MAX_MESSAGE_LENGTH);
}
}
EndDrawing();
if(oxygen < 0.1f) {
player_health -= dt * 20.0f;
}
if(taking_panorama) {
if(panorama_step >= 0) {
char name[16];
sprintf(name, "%d.png", panorama_step);
TakeScreenshot(name);
}
panorama_step++;
}
}
static void GameStart() {
const int cloudMapSize = MAX_WORLD_SIZE*CHUNK_SIZE/8;
for (int x = 0; x < cloudMapSize; x++)
{
for (int y = 0; y < cloudMapSize; y++) {
clouds.set(y * cloudMapSize + x, GetCloud(x*8, y*8));
}
}
LoadPlayerData();
//PlayRandomMusic();
char data[1];
data[0] = NET_ARG_REQPLAYERS;
SendPacketR(peer, data, 1);
camera = { 0 };
camera.position = (Vector3){ MAX_WORLD_SIZE / 2 * CHUNK_SIZE, 12.0f, MAX_WORLD_SIZE / 2 * CHUNK_SIZE};
camera.target = (Vector3){camera.position.x, camera.position.y, camera.position.z + 1};
camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
camera.fovy = FOV;
camera.projection = CAMERA_PERSPECTIVE;
int center = MAX_WORLD_SIZE / 2 * CHUNK_SIZE;
player_position = (Vector3){ MAX_WORLD_SIZE / 2 * CHUNK_SIZE, 128.0f, MAX_WORLD_SIZE / 2 * CHUNK_SIZE};
player_position.y = world[GetIndexWorld(center / 16, center / 16)].highestBlock[0] + 2;
player_velocity = (Vector3){ 0, 0, 0 };
DisableCursor();
InitHotbar();
SetTargetFPS(-1);
wood_place = LoadSound(Pathify("sound/block_wood.wav"));
stone_place = LoadSound(Pathify("sound/block_stone.wav"));
dirt_place = LoadSound(Pathify("sound/block_dirt.wav"));
grass_place = LoadSound(Pathify("sound/block_grass.wav"));
}
static void CreateNetPlayer(int id) {
Entity temp = NewEntity();
temp.type = 1;
temp.position = player_position;
temp.data[0] = id;
temp.data[1] = 0;
AddEntity(temp);
}
static void RemovePlayerEntity(int id) {
auto match = [&](const Entity ent){
return ent.data[0] == id && ent.type == 1;
};
auto it = std::find_if(entities.begin(), entities.end(), match);
if (it != entities.end()) {
entities.erase(it);
}
}
static void ParseMessagePacket(std::vector<unsigned char> &a_data) {
std::string output;
if(a_data[1] == 255) {
output += std::string("[Server] ");
}
for (int i = 0; i < a_data[2]; ++i) {
output.push_back(static_cast<char>(a_data[3 + i]));
}
MessageData msg;
msg.lifetime = 0;
msg.message = output;
messages.push_back(msg);
}
static void ParseData(ENetPacket* packet) {
int len = packet->dataLength;
std::vector<unsigned char> a_data;
std::cout << "Processing packet: " << len << "b ;";
for (int i = 0; i < len; i++)
{
a_data.push_back(packet->data[i]);
}
switch (a_data[0])
{
case NET_ARG_CHUNKF:
puts("Server sent a chunk, caching for later use");
worldPacketStack.push(a_data);
break;
case NET_ARG_PLRID:
plrId = a_data[1];
std::cout << "Server assigned ID:" << plrId << std::endl;
break;
case NET_ARG_PLRCON:
puts("Player connected");
if(a_data[1] != plrId) {
CreateNetPlayer(a_data[1]);
}
break;
case NET_ARG_PLRDCN:
puts("Player disconnected");
RemovePlayerEntity(a_data[1]);
break;
case NET_ARG_ECHOMOVE:
std::cout << "Server requested to sync pos " << (int)(a_data[1]) << std::endl;
if(a_data[1] == plrId) {
float x = DeserializeFloat(a_data[2],a_data[3]);
float y = DeserializeFloat(a_data[4],a_data[5]);
float z = DeserializeFloat(a_data[6],a_data[7]);
player_position.x = x;
player_position.y = y;
player_position.z = z;
}
for (Entity &plr : entities)
{
std::cout << (int)(plr.data[0]) << " " << (int)(plr.type) << std::endl;
if(plr.data[0] == a_data[1] && plr.type == 1) {
float x = DeserializeFloat(a_data[2],a_data[3]);
float y = DeserializeFloat(a_data[4],a_data[5]);
float z = DeserializeFloat(a_data[6],a_data[7]);
plr.position.x = x;
plr.position.y = y;
plr.position.z = z;
//plr.yaw = (short)floorf(a_data[8] / 255.0f* 65536);
plr.data[1] = 255;
std::cout << x << " " << y << " " << z << " " << (float)(plr.yaw) << std::endl;
}
}
break;
case NET_ARG_ECHOYAW:
std::cout << "Server requested to sync yaw " << (int)(a_data[1]) << std::endl;
for (Entity &plr : entities)
{
if(plr.data[0] == a_data[1] && plr.type == 1) {
plr.yaw = (short)floorf(a_data[2] / 255.0f * 65536);
}
}
break;
case NET_ARG_PLRREG:
puts("Got a connected player");
if(a_data[1] != plrId) {
CreateNetPlayer(a_data[1]);
}
for (Entity &plr : entities)
{
if(plr.data[0] == a_data[1] && plr.type == 1) {
float x = DeserializeFloat(a_data[2],a_data[3]);
float y = DeserializeFloat(a_data[4],a_data[5]);
float z = DeserializeFloat(a_data[6],a_data[7]);
plr.position.x = x;
plr.position.y = y;
plr.position.z = z;
plr.yaw = (short)floorf(a_data[8] / 255.0f * 65536);
}
}
break;
case NET_ARG_BLOCK:
SetBlock(world, a_data[2], a_data[3], a_data[4], a_data[5]);
dirtyChunks[GetIndexWorld(a_data[2] / 16, a_data[4] / 16)] = true;
if(a_data[2] == 0) {
dirtyChunks[GetIndexWorld(a_data[2] / 16-1, a_data[4] / 16)] = true;
}
if(a_data[2] == CHUNK_SIZE-1) {
dirtyChunks[GetIndexWorld(a_data[2] / 16+1, a_data[4] / 16)] = true;
}
if(a_data[4] == 0) {
dirtyChunks[GetIndexWorld(a_data[2] / 16, a_data[4] / 16-1)] = true;
}
if(a_data[4] == CHUNK_SIZE-1) {
dirtyChunks[GetIndexWorld(a_data[2] / 16, a_data[4] / 16+1)] = true;
}
break;
case NET_ARG_MESSAGEE:
ParseMessagePacket(a_data);
break;
default:
puts("Malformed data?");
break;
}
}
Vector3 player_positionPrev;
float yawPrev;
void NetworkUpdate() {
if(!online) return;
if(state == GAME_STATE_GAME) {
float dist = Vector3Distance(player_positionPrev, player_position);
if(dist > 0.05f) {
char data[8];
data[0] = NET_ARG_PLAYERMOVE;
SerializeFloat2Data(player_position.x, &data, 1);
SerializeFloat2Data(player_position.y, &data, 3);
SerializeFloat2Data(player_position.z, &data, 5);
float deg = camYaw * RAD2DEG;
int wrapped = (int)(deg + 180) % 360;
float scaled = wrapped / 360.0f * 255.0f;
int iv = (int)floorf(scaled + 0.5f);
if (iv < 0) iv = 0;
if (iv > 255) iv = 255;
data[7] = (uint8_t)iv;
SendPacket(peer, &data, sizeof(data));
player_positionPrev = player_position;
}
float yawDist = camYaw - yawPrev;
if(abs(yawDist) > 0.25f) {
char data[2];
data[0] = NET_ARG_PLAYERYAW;
float deg = camYaw * RAD2DEG;
int wrapped = (int)(deg + 180) % 360;
float scaled = wrapped / 360.0f * 255.0f;
int iv = (int)floorf(scaled + 0.5f);
iv &= 0xFF;
data[1] = (uint8_t)iv;
SendPacket(peer, &data, sizeof(data));
yawPrev = camYaw;
}
}
ENetEvent event;
while(enet_host_service(client, &event, 2) > 0)
{
switch(event.type)
{
case ENET_EVENT_TYPE_RECEIVE:
ParseData(event.packet);
enet_packet_destroy(event.packet);
break;
case ENET_EVENT_TYPE_DISCONNECT:
puts("Disconnection succeeded.");
break;
}
}
}
void GameModeCleanupFull() {
if(online) {
enet_host_destroy(client);
online = false;
}
for (int idx = 0; idx < MAX_WORLD_AREA; idx++)
{
if(loadedChunks[idx]) {
//UnloadModel(renderingT[idx]);
//UnloadModel(rendering[idx]);
}
}
memset(loadedChunks, 0, sizeof(loadedChunks));
memset(dirtyChunks, 0, sizeof(dirtyChunks));
entities.clear();
}
void GameModeCleanup() {
state = GAME_STATE_TRANSITION;
SaveWorld(world, "tempworld.data");
SavePlayerData();
pauseMenuActive = false;
EnableCursor();
GameModeCleanupFull();
state = GAME_STATE_MAINMENU;
worldCreationProgress = 0;
worldCreationStep = 0;
}
extern void InitMenu();
int main(void)
{
SetTraceLogLevel(LOG_WARNING);
SetConfigFlags(FLAG_WINDOW_RESIZABLE);
InitWindow(WIDTH, HEIGHT, GAME_NAME);
InitWorldgen(0);
InitAudioDevice();
InitMenu();
InputInit();
EntitiesInit();
LocaleUpdate();
LoadRecipes();
camera = { 0 };
camera.position = (Vector3){0, 0, 0};
camera.target = (Vector3){camera.position.x, camera.position.y, camera.position.z + 1};
camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
camera.fovy = 90;
camera.projection = CAMERA_PERSPECTIVE;
fnt = LoadFontEx(Pathify("font.ttf"), 32, NULL, 1024*8);
terrain = LoadTexture(Pathify("terrain.png"));
GenTextureMipmaps(&terrain);
Image temp = GenImageColor(1, 1, WHITE);
white_pixel = LoadTextureFromImage(temp);
Image src = LoadImageFromTexture(terrain);
UVCorners uvs = GetUVTex(14);
Rectangle src0;
src0.x = uvs.corner2.x * terrain.width;
src0.y = uvs.corner2.y * terrain.height;
src0.width = (uvs.corner3.x - uvs.corner2.x) * terrain.width;
src0.height = (uvs.corner1.y - uvs.corner2.y) * terrain.height;
Image copied = ImageCopy(src);
ImageCrop(&copied, src0);
water = LoadTextureFromImage(copied);
SetTextureWrap(water, TEXTURE_WRAP_REPEAT);
SetTargetFPS(-1);
float time;
SetExitKey(KEY_NULL);
while (!WindowShouldClose())
{
NetworkUpdate();
InputUpdate();
while (worldPacketStack.size() > 0)
{
std::vector<unsigned char> data = worldPacketStack.top();
int idx = (int)(data[1]);
std::cout << "Processing chunk " << (int)idx << std::endl;
Chunk c;
int x, z;
GetXZFromIndex(idx, &x, &z);
c.x = (uint8_t)x;
c.z = (uint8_t)z;
std::cout << data.size() << std::endl;
for (int i = 2; i < CHUNK_DATA_SIZE+2; i++)
{
c.blocks[i-2] = data[i];
}
for (int i = CHUNK_DATA_SIZE+2; i < CHUNK_DATA_SIZE+2+CHUNK_SIZE*CHUNK_SIZE; i++)
{
c.highestBlock[i-CHUNK_DATA_SIZE-2] = data[i];
}
world[idx] = c;
dirtyChunks[idx] = true;
worldPacketStack.pop();
fetchedChunks++;
}
std::string text0 = LocaleGet("step_0");
char text[64];
switch (state)
{
case GAME_STATE_GAME:
GameUpdate(camera, time);
break;
case GAME_STATE_LOADING:
// World creation crap
BeginDrawing();
DrawBackground();
if(worldCreationStep == 1) {
text0 = LocaleGet("step_1");
}
if(worldCreationStep == 2) {
text0 = LocaleGet("step_2");
}
if(worldCreationStep == 3) {
text0 = LocaleGet("step_3");
}
DrawTextB(text0.c_str(), GetScreenWidth()/2 - 64, GetScreenHeight()/2 - 32, DEFAULT_FONT_SIZE, WHITE);
if(worldCreationStep != 1) {
DrawRectangle( GetScreenWidth()/2-64, GetScreenHeight()/2, 128, 16, BLACK);
DrawRectangle( GetScreenWidth()/2-62, GetScreenHeight()/2 + 2, 124 * ((float)worldCreationProgress / static_cast<float>(MAX_WORLD_AREA)), 12, GREEN);
sprintf(text, LocaleGet("chunk_status").c_str(), worldCreationProgress, MAX_WORLD_AREA);
DrawTextB(text, GetScreenWidth()/2 - 32, GetScreenHeight()/2 + 32, DEFAULT_FONT_SIZE, WHITE);
}
EndDrawing();
// * Well, there was a loop here.
if(worldCreationProgress < MAX_WORLD_AREA) {
for (int _ = 0; _ < 16; _++)
{
int x = worldCreationProgress % MAX_WORLD_SIZE;
int y = worldCreationProgress / MAX_WORLD_SIZE;
int idx = x + y * MAX_WORLD_SIZE;
if(worldCreationStep == 0 && !online) {
Chunk chunk = GenerateChunk(x, y);
world[idx] = chunk;
}
if(worldCreationStep == 1 && !online) {
if(worldCreationProgress > 0) {
worldCreationStep++;
}
else {
GenerateWorldAdditional(world);
}
}
if (worldCreationStep == 2)
{
//RebuildOpaqueMask(&world[idx]);
}
if (worldCreationStep == 3) {
dirtyChunks[idx] = true;
}
if(online)
worldCreationProgress = fetchedChunks+1;
}
}
else {
if(worldCreationStep <= 2) {
worldCreationProgress = 0;
worldCreationStep++;
}
else {
state = GAME_STATE_GAME;
GameStart();
break;
}
}
break;
case GAME_STATE_MAINMENU:
DrawMainMenu();
break;
case GAME_STATE_WORLDSELECT:
DrawWorldSelect();
break;
case GAME_STATE_MULTIPLAYERSELECT:
DrawMultiplayer();
break;
case GAME_STATE_TRANSITION:
DrawLogoCenter();
break;
case GAME_STATE_OPTIONS:
DrawControls();
break;
}
}
GameModeCleanupFull();
UnloadTexture(terrain);
CloseWindow();
return 0;
}
Reference in New Issue View Git Blame Copy Permalink