Minecraft clone for Windows, Mac OS X and Linux. Just a few thousand lines of C using modern OpenGL (shaders).

Credit to Michael Fogleman for the bulk of the code used in this forked project.

• Ronni Hartlage
• Madison Perry
• Benjamin Hardesty

• New Theme: "The Moon"
  • Rocky terrain
  • Dark sky
  • Stars in the sky (removed clouds)
  • Decreased gravity (higher jumps, slower fall time)
  • View of the Earth in the sky
• Sprint by holding Q
• Doxygen formatted comments added

• Simple but nice looking terrain generation using perlin / simplex noise.
• More than 10 types of blocks and more can be added easily.
• Supports plants (grass, flowers, trees, etc.) and transparency (glass).
• Simple clouds in the sky (they don't move).
• Day / night cycles and a textured sky dome.
• World changes persisted in a sqlite3 database.
• Multiplayer support!

Download and install CMake if you don't already have it. You may use Homebrew to simplify the installation:

brew install cmake

sudo apt-get install cmake libglew-dev xorg-dev libcurl4-openssl-dev
sudo apt-get build-dep glfw

Download and install CMake and MinGW. Add C:\MinGW\bin to your PATH.

Download and install cURL so that CURL/lib and CURL/include are in your Program Files directory.

Use the following commands in place of the ones described in the next section.

cmake -G "MinGW Makefiles"
mingw32-make

Once you have the dependencies (see above), run the following commands in your terminal.

git clone https://github.com/fogleman/Craft.git
cd Craft
cmake .
make
./craft

You can connect to a server with command line arguments...

./craft [HOST [PORT]]

Or, with the "/online" command in the game itself.

/online [HOST [PORT]]

You can run your own server or connect to mine. The server is written in Python but requires a compiled DLL so it can perform the terrain generation just like the client.

gcc -std=c99 -O3 -fPIC -shared -o world -I src -I deps/noise deps/noise/noise.c src/world.c
python server.py [HOST [PORT]]

• WASD to move forward, left, backward, right.
• Q to sprint.
• Space to jump.
• Left Click to destroy a block.
• Right Click or Cmd + Left Click to create a block.
• Ctrl + Right Click to toggle a block as a light source.
• 1-9 to select the block type to create.
• E to cycle through the block types.
• Tab to toggle between walking and flying.
• ZXCVBN to move in exact directions along the XYZ axes.
• Left shift to zoom.
• F to show the scene in orthographic mode.
• O to observe players in the main view.
• P to observe players in the picture-in-picture view.
• T to type text into chat.
• Forward slash (/) to enter a command.
• Backquote (`) to write text on any block (signs).
• Arrow keys emulate mouse movement.
• Enter emulates mouse click.

/goto [NAME]

Teleport to another user. If NAME is unspecified, a random user is chosen.

/list

Display a list of connected users.

/login NAME

Switch to another registered username. The login server will be re-contacted. The username is case-sensitive.

/logout

Unauthenticate and become a guest user. Automatic logins will not occur again until the /login command is re-issued.

/offline [FILE]

Switch to offline mode. FILE specifies the save file to use and defaults to "craft".

/online HOST [PORT]

Connect to the specified server.

/pq P Q

Teleport to the specified chunk.

/spawn

Teleport back to the spawn point.

The terrain is generated using Simplex noise - a deterministic noise function seeded based on position. So the world will always be generated the same way in a given location.

The world is split up into 32x32 block chunks in the XZ plane (Y is up). This allows the world to be “infinite” (floating point precision is currently a problem at large X or Z values) and also makes it easier to manage the data. Only visible chunks need to be queried from the database.

Only exposed faces are rendered. This is an important optimization as the vast majority of blocks are either completely hidden or are only exposing one or two faces. Each chunk records a one-block width overlap for each neighboring chunk so it knows which blocks along its perimeter are exposed.

Only visible chunks are rendered. A naive frustum-culling approach is used to test if a chunk is in the camera’s view. If it is not, it is not rendered. This results in a pretty decent performance improvement as well.

Chunk buffers are completely regenerated when a block is changed in that chunk, instead of trying to update the VBO.

Text is rendered using a bitmap atlas. Each character is rendered onto two triangles forming a 2D rectangle.

“Modern” OpenGL is used - no deprecated, fixed-function pipeline functions are used. Vertex buffer objects are used for position, normal and texture coordinates. Vertex and fragment shaders are used for rendering. Matrix manipulation functions are in matrix.c for translation, rotation, perspective, orthographic, etc. matrices. The 3D models are made up of very simple primitives - mostly cubes and rectangles. These models are generated in code in cube.c.

Transparency in glass blocks and plants (plants don’t take up the full rectangular shape of their triangle primitives) is implemented by discarding magenta-colored pixels in the fragment shader.

User changes to the world are stored in a sqlite database. Only the delta is stored, so the default world is generated and then the user changes are applied on top when loading.

The main database table is named “block” and has columns p, q, x, y, z, w. (p, q) identifies the chunk, (x, y, z) identifies the block position and (w) identifies the block type. 0 represents an empty block (air).

In game, the chunks store their blocks in a hash map. An (x, y, z) key maps to a (w) value.

The y-position of blocks are limited to 0 <= y < 256. The upper limit is mainly an artificial limitation to prevent users from building unnecessarily tall structures. Users are not allowed to destroy blocks at y = 0 to avoid falling underneath the world.

Hit testing (what block the user is pointing at) is implemented by scanning a ray from the player’s position outward, following their sight vector. This is not a precise method, so the step rate can be made smaller to be more accurate.

Collision testing simply adjusts the player’s position to remain a certain distance away from any adjacent blocks that are obstacles. (Clouds and plants are not marked as obstacles, so you pass right through them.)

A textured sky dome is used for the sky. The X-coordinate of the texture represents time of day. The Y-values map from the bottom of the sky sphere to the top of the sky sphere. The player is always in the center of the sphere. The fragment shaders for the blocks also sample the sky texture to determine the appropriate fog color to blend with based on the block’s position relative to the backing sky.

Ambient occlusion is implemented as described on this page:

http:https://0fps.wordpress.com/2013/07/03/ambient-occlusion-for-minecraft-like-worlds/

The documentation for using Doxygen can be found at the following site:

https://www.doxygen.nl/index.html

1. add Doxygen formatted comments to source code (see https://www.doxygen.nl/manual/docblocks.html)
2. run the following commands

cd src
doxygen

3. open the html folder generated and click on any of the html files to open the documentation in your browser

• GLEW is used for managing OpenGL extensions across platforms.
• GLFW is used for cross-platform window management.
• CURL is used for HTTPS / SSL POST for the authentication process.
• lodepng is used for loading PNG textures.
• sqlite3 is used for saving the blocks added / removed by the user.
• tinycthread is used for cross-platform threading.