refactor: make code more meaningful

Author: Gumichocopengin8

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.10)
+cmake_minimum_required(VERSION 3.20)
 project(project)
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++20 -framework GLUT -framework OpenGL")

biome/Biome.cpp

@@ -3,15 +3,16 @@
 //
 
 #include <cmath>
+#include <utility>
 #include "Biome.h"
 
 Biome::Biome(std::string id, int x, int z, BiomeType *type) {
-  this->id = id;
+  this->id = std::move(id);
   this->x = x;
   this->z = z;
   this->type = type;
 }
 
-float Biome::distance_to(float x, float z) {
+float Biome::distance_to(float x, float z) const {
   return pow(x - this->x, 2) + pow(z - this->z, 2);
 }

biome/Biome.h

@@ -19,7 +19,7 @@ class Biome {
 
   explicit Biome(std::string id, int x, int z, BiomeType *type);
 
-  float distance_to(float x, float z);
+  [[nodiscard]] float distance_to(float x, float z) const;
 };
 
 

block/Block.cpp

@@ -17,7 +17,7 @@ Block::Block(int type, int x, int y, int z) {
   this->z = z;
 }
 
-void Block::render() {
+void Block::render() const {
 
   // Transforms
   glPushMatrix();
@@ -26,18 +26,43 @@ void Block::render() {
   // Texture
   Texture texture;
 
-  if (this->type == GROUND) { texture.ground(); }
-  else if (this->type == GRASS) { texture.grass(); }
-  else if (this->type == TREETRUNK) { texture.treeTrunk(); }
-  else if (this->type == TREELEAVES) { texture.treeLeaves(); }
-  else if (this->type == SNOW) { texture.snow(); }
-  else if (this->type == WATER) { texture.water(); }
-  else if (this->type == CLOUD) { texture.cloud(); }
-  else if (this->type == ORANGE) { texture.orange(); }
-  else if (this->type == LAWNGREEN) { texture.lawngreen(); }
-  else if (this->type == SAND) { texture.sand(); }
-  else if (this->type == ROCK) { texture.rock(); }
-  else { texture.ground(); }
+  switch (this->type) {
+    case GROUND:
+      texture.ground();
+      break;
+    case GRASS:
+      texture.grass();
+      break;
+    case TREETRUNK:
+      texture.treeTrunk();
+      break;
+    case TREELEAVES:
+      texture.treeLeaves();
+      break;
+    case SNOW:
+      texture.snow();
+      break;
+    case WATER:
+      texture.water();
+      break;
+    case CLOUD:
+      texture.cloud();
+      break;
+    case ORANGE:
+      texture.orange();
+      break;
+    case LAWNGREEN:
+      texture.lawngreen();
+      break;
+    case SAND:
+      texture.sand();
+      break;
+    case ROCK:
+      texture.rock();
+      break;
+    default:
+      texture.ground();
+  }
 
   glutSolidCube(1);
   glPopMatrix();

block/Block.h

@@ -19,7 +19,7 @@ class Block {
 public:
   explicit Block(int type, int x, int y, int z);
 
-  void render();
+  void render() const;
 };
 
 

camera/Camera.cpp

@@ -19,7 +19,7 @@ namespace {
 }
 
 
-Camera::Camera(double camera_x, double camera_y, double camera_z, double pitch, double yaw, double roll) {
+Camera::Camera(float camera_x, float camera_y, float camera_z, float pitch, float yaw, float roll) {
   this->camera_x = camera_x;
   this->camera_y = camera_y;
   this->camera_z = camera_z;
@@ -68,9 +68,9 @@ void Camera::move_x(float speed) {
   if (this->x_speed < -MAX_HORIZONTAL_SPEED) this->x_speed = -MAX_HORIZONTAL_SPEED;
 
 
-  double new_camera_x = this->camera_x + sin(this->yaw) * cos(this->pitch) * this->x_speed;
-  double new_camera_y = this->camera_y + sin(this->pitch) * speed;
-  double new_camera_z = this->camera_z - cos(this->yaw) * cos(this->pitch) * this->x_speed;
+  float new_camera_x = this->camera_x + sin(this->yaw) * cos(this->pitch) * this->x_speed;
+  float new_camera_y = this->camera_y + sin(this->pitch) * speed;
+  float new_camera_z = this->camera_z - cos(this->yaw) * cos(this->pitch) * this->x_speed;
 
 
   if (worldPtr->getBlock(round(new_camera_x), round(new_camera_y) - CAMERA_HEIGHT, round(new_camera_z)) == 0) {
@@ -88,8 +88,8 @@ void Camera::move_z(float speed) {
   if (this->z_speed > MAX_HORIZONTAL_SPEED) this->z_speed = MAX_HORIZONTAL_SPEED;
   if (this->z_speed < -MAX_HORIZONTAL_SPEED) this->z_speed = -MAX_HORIZONTAL_SPEED;
 
-  double new_camera_x = this->camera_x + cos(this->yaw) * this->z_speed;
-  double new_camera_z = this->camera_z + sin(this->yaw) * this->z_speed;
+  float new_camera_x = this->camera_x + cos(this->yaw) * this->z_speed;
+  float new_camera_z = this->camera_z + sin(this->yaw) * this->z_speed;
 
   this->camera_x = new_camera_x;
   this->camera_z = new_camera_z;
@@ -100,7 +100,7 @@ void Camera::move_y(float speed) {
   if (this->y_speed > MAX_VERTICAL_SPEED) this->y_speed = MAX_VERTICAL_SPEED;
   if (this->y_speed < -MAX_VERTICAL_SPEED) this->y_speed = -MAX_VERTICAL_SPEED;
 
-  double new_camera_y = this->camera_y + cos(this->pitch) * this->y_speed;
+  float new_camera_y = this->camera_y + cos(this->pitch) * this->y_speed;
 
   if (worldPtr->getBlock(round(this->camera_x), new_camera_y - CAMERA_HEIGHT, round(this->camera_z)) == 0) {
     this->camera_y = new_camera_y;

camera/Camera.h

@@ -9,19 +9,19 @@
 
 class Camera {
 private:
-  double pitch; // x rotation
-  double yaw; // y rotation
-  double roll; // z rotation
+  float pitch; // x rotation
+  float yaw; // y rotation
+  float roll; // z rotation
 
 public:
-  double camera_x;
-  double camera_y;
-  double camera_z;
-  double x_speed;
-  double y_speed;
-  double z_speed;
-
-  explicit Camera(double camera_x, double camera_y, double camera_z, double pitch, double yaw, double roll);
+  float camera_x;
+  float camera_y;
+  float camera_z;
+  float x_speed;
+  float y_speed;
+  float z_speed;
+
+  explicit Camera(float camera_x, float camera_y, float camera_z, float pitch, float yaw, float roll);
 
   void refresh(Light light);
 

chunk/Chunk.cpp

@@ -3,6 +3,7 @@
 //
 
 #include <iostream>
+#include <random>
 #include <string>
 
 #include "Chunk.h"
@@ -50,17 +51,11 @@ Chunk::Chunk(int chunk_x, int chunk_z, BiomeType *biome) {
       if (new_percent_j > 1) new_percent_j = 1;
 
 
-      int height;
-
-      if (this->biome->id == "mountain") {
-        height = round(perlin.octaveNoise0_1(i / fx, j / fy, octaves) * 40);
-      } else {
-        height = round(perlin.octaveNoise0_1(i / fx, j / fy, octaves) * 20);
-      }
+      float height = roundf(
+        perlin.octaveNoise0_1(i / fx, j / fy, octaves) * (this->biome->id == "mountain" ? 40 : 20));
 
-
-      int old_height_i = -1;
-      int old_height_j = -1;
+      float old_height_i = -1;
+      float old_height_j = -1;
 
 
       // Get adjacent i height
@@ -73,22 +68,22 @@ Chunk::Chunk(int chunk_x, int chunk_z, BiomeType *biome) {
       }
 
       if (i > 10) {
-        int temp_old_height = worldPtr->getTerrainHeight((1 + this->x) * 16, this->z * 16 + j);
+        float temp_old_height = worldPtr->getTerrainHeight((1 + this->x) * 16, this->z * 16 + j);
         if (temp_old_height != -1)
           old_height_i = temp_old_height;
       }
 
       // Get adjacent j height
 
       if (j < 5) {
-        int temp_old_height = worldPtr->getTerrainHeight(this->x * 16 + i, this->z * 16 - 1);
+        float temp_old_height = worldPtr->getTerrainHeight(this->x * 16 + i, this->z * 16 - 1);
 
         if (temp_old_height != -1)
           old_height_j = temp_old_height;
       }
 
       if (j > 10) {
-        int temp_old_height = worldPtr->getTerrainHeight(this->x * 16 + i, (1 + this->z) * 16);
+        float temp_old_height = worldPtr->getTerrainHeight(this->x * 16 + i, (1 + this->z) * 16);
 
         if (temp_old_height != -1)
           old_height_j = temp_old_height;
@@ -292,11 +287,3 @@ void Chunk::generateStructures() {
     }
   }
 }
-
-float Chunk::distance_to(Chunk *other) {
-  return pow(other->x - this->x, 2) + pow(other->z - this->z, 2);
-}
-
-float Chunk::distance_to(float x, float z) {
-  return pow(x - this->x, 2) + pow(z - this->z, 2);
-}

chunk/Chunk.h

@@ -21,8 +21,8 @@ class Chunk {
   int z;
   BiomeType *biome; // TODO
 
-  int blocks[CHUNK_SIZE][CHUNK_HEIGHT][CHUNK_SIZE];
-  int heights[CHUNK_SIZE][CHUNK_SIZE];
+  int blocks[CHUNK_SIZE][CHUNK_HEIGHT][CHUNK_SIZE]{};
+  int heights[CHUNK_SIZE][CHUNK_SIZE]{};
 
   explicit Chunk(int chunk_x, int chunk_z, BiomeType *biome);
 
@@ -34,10 +34,6 @@ class Chunk {
 
   int getHeight(int x, int z);
 
-  float distance_to(Chunk *other);
-
-  float distance_to(float x, float z);
-
   void generateStructures();
 
   void removeHiddenBlocks();

chunk/PerlinNoise.hpp

@@ -36,7 +36,7 @@ namespace siv {
   class PerlinNoise {
   private:
 
-    std::int32_t p[512];
+    std::int32_t p[512]{};
 
     static double Fade(double t) noexcept {
       return t * t * t * (t * (t * 6 - 15) + 10);
@@ -89,15 +89,15 @@ namespace siv {
       }
     }
 
-    double noise(double x) const {
+    [[nodiscard]] double noise(double x) const {
       return noise(x, 0.0, 0.0);
     }
 
-    double noise(double x, double y) const {
+    [[nodiscard]] double noise(double x, double y) const {
       return noise(x, y, 0.0);
     }
 
-    double noise(double x, double y, double z) const {
+    [[nodiscard]] double noise(double x, double y, double z) const {
       const std::int32_t X = static_cast<std::int32_t>(std::floor(x)) & 255;
       const std::int32_t Y = static_cast<std::int32_t>(std::floor(y)) & 255;
       const std::int32_t Z = static_cast<std::int32_t>(std::floor(z)) & 255;
@@ -123,7 +123,7 @@ namespace siv {
                             Grad(p[BB + 1], x - 1, y - 1, z - 1))));
     }
 
-    double octaveNoise(double x, std::int32_t octaves) const {
+    [[nodiscard]] double octaveNoise(double x, std::int32_t octaves) const {
       double result = 0.0;
       double amp = 1.0;
 
@@ -136,7 +136,7 @@ namespace siv {
       return result;
     }
 
-    double octaveNoise(double x, double y, std::int32_t octaves) const {
+    [[nodiscard]] double octaveNoise(double x, double y, std::int32_t octaves) const {
       double result = 0.0;
       double amp = 1.0;
 
@@ -150,7 +150,7 @@ namespace siv {
       return result;
     }
 
-    double octaveNoise(double x, double y, double z, std::int32_t octaves) const {
+    [[nodiscard]] double octaveNoise(double x, double y, double z, std::int32_t octaves) const {
       double result = 0.0;
       double amp = 1.0;
 
@@ -165,27 +165,27 @@ namespace siv {
       return result;
     }
 
-    double noise0_1(double x) const {
+    [[nodiscard]] double noise0_1(double x) const {
       return noise(x) * 0.5 + 0.5;
     }
 
-    double noise0_1(double x, double y) const {
+    [[nodiscard]] double noise0_1(double x, double y) const {
       return noise(x, y) * 0.5 + 0.5;
     }
 
-    double noise0_1(double x, double y, double z) const {
+    [[nodiscard]] double noise0_1(double x, double y, double z) const {
       return noise(x, y, z) * 0.5 + 0.5;
     }
 
-    double octaveNoise0_1(double x, std::int32_t octaves) const {
+    [[nodiscard]] double octaveNoise0_1(double x, std::int32_t octaves) const {
       return octaveNoise(x, octaves) * 0.5 + 0.5;
     }
 
-    double octaveNoise0_1(double x, double y, std::int32_t octaves) const {
+    [[nodiscard]] double octaveNoise0_1(double x, double y, std::int32_t octaves) const {
       return octaveNoise(x, y, octaves) * 0.5 + 0.5;
     }
 
-    double octaveNoise0_1(double x, double y, double z, std::int32_t octaves) const {
+    [[nodiscard]] double octaveNoise0_1(double x, double y, double z, std::int32_t octaves) const {
       return octaveNoise(x, y, z, octaves) * 0.5 + 0.5;
     }
   };