first import

main
Steffen Pohle 2 days ago
parent f16dd066c2
commit 05dc4c68ab

2
.gitignore vendored

@ -0,0 +1,2 @@
/build/
/dist/

@ -0,0 +1,40 @@
CXX ?= g++
MINGW_CXX ?= x86_64-w64-mingw32-g++
VERSION ?= 0.1
BUILD_DIR ?= build
DIST_DIR ?= dist
SDL2_CROSS_ROOT ?= /usr/x86_64-w64-mingw32
APP := 3dtetris
VERSION_FLAG := -DGAME_VERSION=\"$(VERSION)\"
COMMON_FLAGS := -std=c++17 -Wall -Wextra -pedantic
SDL2_CFLAGS := $(shell pkg-config --cflags sdl2 gl)
SDL2_LIBS := $(shell pkg-config --libs sdl2 gl)
SDL2_CROSS_CFLAGS := -I$(SDL2_CROSS_ROOT)/include/SDL2
SDL2_CROSS_LIBS := -L$(SDL2_CROSS_ROOT)/lib -lmingw32 -lSDL2main -lSDL2 \
-mwindows -lopengl32 -limm32 -lversion -lole32 -loleaut32 -luuid \
-lsetupapi -lwinmm -luser32 -lgdi32 -lshell32 -ladvapi32
.PHONY: all clean bundle-windows
all: $(BUILD_DIR)/$(APP)
$(BUILD_DIR):
mkdir -p $@
$(BUILD_DIR)/$(APP): main.cpp | $(BUILD_DIR)
@pkg-config --exists sdl2 gl || { echo "SDL2 and OpenGL development packages are required (pkg-config: sdl2 gl)." >&2; exit 1; }
$(CXX) $(COMMON_FLAGS) $(SDL2_CFLAGS) $(VERSION_FLAG) -O2 $< -o $@ $(SDL2_LIBS)
$(BUILD_DIR)/$(APP).exe: main.cpp | $(BUILD_DIR)
@test -f "$(SDL2_CROSS_ROOT)/include/SDL2/SDL.h" && \
test -f "$(SDL2_CROSS_ROOT)/lib/libSDL2.a" || { \
echo "Set SDL2_CROSS_ROOT to a MinGW-w64 SDL2 development package root." >&2; exit 1; }
$(MINGW_CXX) $(COMMON_FLAGS) $(SDL2_CROSS_CFLAGS) $(VERSION_FLAG) \
-Os -s -static -static-libgcc -static-libstdc++ $< -o $@ $(SDL2_CROSS_LIBS)
bundle-windows: $(BUILD_DIR)/$(APP).exe
mkdir -p $(DIST_DIR)
cd $(BUILD_DIR) && zip -j ../$(DIST_DIR)/$(APP)-v$(VERSION)-windows-x64.zip $(APP).exe
clean:
rm -rf $(BUILD_DIR) $(DIST_DIR)

@ -0,0 +1,51 @@
# 3D Tetris
A C++17 3D Tetris game rendered with SDL2 and OpenGL. The playfield is six
cells wide, six cells deep, and twelve layers high. Fill a complete horizontal
layer to clear it. Drag with the left mouse button to orbit the 3D view and use
the mouse wheel to zoom.
## Build and run
Install SDL2 and OpenGL development libraries, plus `pkg-config`, then build
and run on Linux:
```sh
make
./build/3dtetris
```
On Windows, install SDL2 development libraries and compile `main.cpp` with a
C++17 compiler, SDL2, and OpenGL. To cross-compile from Linux, install the
x86_64 MinGW-w64 compiler and download/unpack the SDL2 MinGW development
package. Point `SDL2_CROSS_ROOT` at its `x86_64-w64-mingw32` directory (the
directory containing `include/SDL2` and `lib`):
```sh
make SDL2_CROSS_ROOT=/path/to/SDL2/x86_64-w64-mingw32 bundle-windows
```
The `bundle-windows` target cross-compiles a stripped, statically linked
x86_64 Windows executable and packages only that executable as
`dist/3dtetris-v0.1-windows-x64.zip`. Override `VERSION` to change the version
shown in the window title and used in the archive name, for example:
```sh
make VERSION=0.2 bundle-windows
```
The SDL2 MinGW development package and `zip` must be installed to create the
Windows bundle.
## Controls
- **A / D** or **Left / Right**: move left / right
- **W / S** or **Up / Down**: move across the depth; Down soft-drops
- **Q / E**: rotate
- **Space**: hard drop
- **P**: pause / resume
- **R**: restart
- **Esc**: quit
- **Left mouse drag / wheel**: orbit / zoom the camera
`--help` and `--version` print usage and version information.

@ -0,0 +1,515 @@
#include <SDL.h>
#include <SDL_opengl.h>
#include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <random>
#include <stdexcept>
#include <string>
#ifndef GAME_VERSION
#define GAME_VERSION "0.1"
#endif
namespace {
constexpr int WIDTH = 6;
constexpr int DEPTH = 6;
constexpr int HEIGHT = 12;
struct Cell {
int x;
int y;
int z;
};
struct Piece {
std::array<Cell, 4> cells;
};
const std::array<Piece, 8> PIECES = {{
{{{{0, 0, 0}, {1, 0, 0}, {2, 0, 0}, {3, 0, 0}}}},
{{{{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {1, 1, 0}}}},
{{{{0, 0, 0}, {1, 0, 0}, {2, 0, 0}, {1, 1, 0}}}},
{{{{0, 0, 0}, {0, 1, 0}, {1, 1, 0}, {2, 1, 0}}}},
{{{{0, 0, 0}, {1, 0, 0}, {2, 0, 0}, {2, 1, 0}}}},
{{{{0, 0, 0}, {1, 0, 0}, {1, 1, 0}, {2, 1, 0}}}},
{{{{0, 0, 0}, {1, 0, 0}, {1, 1, 0}, {1, 0, 1}}}},
{{{{0, 0, 0}, {0, 0, 1}, {0, 0, 2}, {0, 0, 3}}}},
}};
const std::array<std::array<float, 3>, PIECES.size()> COLORS = {{
{{0.10f, 0.78f, 0.96f}},
{{0.98f, 0.79f, 0.18f}},
{{0.67f, 0.32f, 0.94f}},
{{0.24f, 0.86f, 0.44f}},
{{0.96f, 0.47f, 0.17f}},
{{0.95f, 0.28f, 0.42f}},
{{0.25f, 0.49f, 0.97f}},
{{0.21f, 0.87f, 0.82f}},
}};
using Layer = std::array<std::array<int, WIDTH>, DEPTH>;
using Board = std::array<Layer, HEIGHT>;
std::runtime_error sdlFailure(const std::string& operation) {
return std::runtime_error(operation + ": " + SDL_GetError());
}
class Game {
public:
Game() : random_(std::random_device{}()) {
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS) != 0) {
throw sdlFailure("SDL_Init failed");
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
window_ = SDL_CreateWindow(
"3D Tetris",
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
1100,
800,
SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
if (window_ == nullptr) {
const auto error = sdlFailure("Could not create SDL window");
SDL_Quit();
throw error;
}
context_ = SDL_GL_CreateContext(window_);
if (context_ == nullptr) {
const auto error = sdlFailure("Could not create OpenGL context");
SDL_DestroyWindow(window_);
window_ = nullptr;
SDL_Quit();
throw error;
}
SDL_GL_SetSwapInterval(1);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
start();
}
~Game() {
if (context_ != nullptr) {
SDL_GL_DeleteContext(context_);
}
if (window_ != nullptr) {
SDL_DestroyWindow(window_);
}
SDL_Quit();
}
Game(const Game&) = delete;
Game& operator=(const Game&) = delete;
void run() {
using Clock = std::chrono::steady_clock;
auto lastFall = Clock::now();
bool running = true;
while (running) {
SDL_Event event;
while (SDL_PollEvent(&event)) {
handleEvent(event, running);
}
const auto now = Clock::now();
if (!gameOver_ && !paused_ &&
now - lastFall >= std::chrono::milliseconds(fallDelay())) {
if (!move(0, 0, -1)) {
lockPiece();
}
lastFall = now;
}
draw();
SDL_Delay(8);
}
}
private:
Board board_{};
std::mt19937 random_;
SDL_Window* window_ = nullptr;
SDL_GLContext context_ = nullptr;
Piece piece_{};
int pieceType_ = 0;
int x_ = 0;
int y_ = 0;
int z_ = 0;
int score_ = 0;
int clearedLayers_ = 0;
float cameraYaw_ = 35.0f;
float cameraPitch_ = 24.0f;
float cameraDistance_ = 19.0f;
bool gameOver_ = false;
bool paused_ = false;
bool dragging_ = false;
int fallDelay() const {
return std::max(100, 700 - (clearedLayers_ / 5) * 50);
}
void start() {
for (auto& layer : board_) {
for (auto& row : layer) {
row.fill(0);
}
}
score_ = 0;
clearedLayers_ = 0;
gameOver_ = false;
paused_ = false;
spawn();
updateTitle();
}
void spawn() {
std::uniform_int_distribution<int> choose(
0, static_cast<int>(PIECES.size()) - 1);
pieceType_ = choose(random_);
piece_ = PIECES[static_cast<std::size_t>(pieceType_)];
x_ = WIDTH / 2 - 1;
y_ = DEPTH / 2 - 1;
int maxZ = 0;
for (const Cell& cell : piece_.cells) {
maxZ = std::max(maxZ, cell.z);
}
z_ = HEIGHT - 1 - maxZ;
if (!fits(x_, y_, z_, piece_)) {
gameOver_ = true;
}
updateTitle();
}
bool fits(int px, int py, int pz, const Piece& candidate) const {
for (const Cell& cell : candidate.cells) {
const int cx = px + cell.x;
const int cy = py + cell.y;
const int cz = pz + cell.z;
if (cx < 0 || cx >= WIDTH || cy < 0 || cy >= DEPTH ||
cz < 0 || cz >= HEIGHT || board_[cz][cy][cx] != 0) {
return false;
}
}
return true;
}
bool move(int dx, int dy, int dz) {
if (!fits(x_ + dx, y_ + dy, z_ + dz, piece_)) {
return false;
}
x_ += dx;
y_ += dy;
z_ += dz;
return true;
}
void rotate() {
Piece rotated = piece_;
int maxY = 0;
for (const Cell& cell : piece_.cells) {
maxY = std::max(maxY, cell.y);
}
for (Cell& cell : rotated.cells) {
const int oldX = cell.x;
cell.x = maxY - cell.y;
cell.y = oldX;
}
if (fits(x_, y_, z_, rotated)) {
piece_ = rotated;
}
}
void hardDrop() {
while (move(0, 0, -1)) {
}
lockPiece();
}
void lockPiece() {
for (const Cell& cell : piece_.cells) {
board_[z_ + cell.z][y_ + cell.y][x_ + cell.x] = pieceType_ + 1;
}
clearFullLayers();
spawn();
}
void clearFullLayers() {
int cleared = 0;
for (int z = 0; z < HEIGHT;) {
bool full = true;
for (int y = 0; y < DEPTH && full; ++y) {
for (int x = 0; x < WIDTH; ++x) {
if (board_[z][y][x] == 0) {
full = false;
break;
}
}
}
if (full) {
for (int layer = z; layer < HEIGHT - 1; ++layer) {
board_[layer] = board_[layer + 1];
}
board_[HEIGHT - 1] = Layer{};
++cleared;
} else {
++z;
}
}
if (cleared > 0) {
clearedLayers_ += cleared;
score_ += cleared * cleared * 100;
}
}
void handleEvent(const SDL_Event& event, bool& running) {
if (event.type == SDL_QUIT) {
running = false;
return;
}
if (event.type == SDL_MOUSEBUTTONDOWN &&
event.button.button == SDL_BUTTON_LEFT) {
dragging_ = true;
return;
}
if (event.type == SDL_MOUSEBUTTONUP &&
event.button.button == SDL_BUTTON_LEFT) {
dragging_ = false;
return;
}
if (event.type == SDL_MOUSEMOTION && dragging_) {
cameraYaw_ += event.motion.xrel * 0.5f;
cameraPitch_ = std::clamp(
cameraPitch_ - event.motion.yrel * 0.5f, 5.0f, 80.0f);
return;
}
if (event.type == SDL_MOUSEWHEEL) {
cameraDistance_ = std::clamp(
cameraDistance_ - event.wheel.y, 10.0f, 35.0f);
return;
}
if (event.type != SDL_KEYDOWN || event.key.repeat != 0) {
return;
}
switch (event.key.keysym.sym) {
case SDLK_ESCAPE:
running = false;
break;
case SDLK_r:
start();
break;
case SDLK_p:
if (!gameOver_) {
paused_ = !paused_;
updateTitle();
}
break;
default:
if (gameOver_ || paused_) {
break;
}
handleGameKey(event.key.keysym.sym);
break;
}
}
void handleGameKey(SDL_Keycode key) {
switch (key) {
case SDLK_a:
case SDLK_LEFT:
move(-1, 0, 0);
break;
case SDLK_d:
case SDLK_RIGHT:
move(1, 0, 0);
break;
case SDLK_w:
case SDLK_UP:
move(0, 1, 0);
break;
case SDLK_s:
case SDLK_DOWN:
if (key == SDLK_DOWN) {
if (!move(0, 0, -1)) {
lockPiece();
}
} else {
move(0, -1, 0);
}
break;
case SDLK_q:
rotate();
break;
case SDLK_e:
rotate();
rotate();
rotate();
break;
case SDLK_SPACE:
hardDrop();
break;
default:
break;
}
}
void updateTitle() const {
std::string title = "3D Tetris v" GAME_VERSION " | Score: " +
std::to_string(score_) + " | Layers: " +
std::to_string(clearedLayers_);
if (gameOver_) {
title += " | GAME OVER - press R to restart";
} else if (paused_) {
title += " | PAUSED";
} else {
title += " | drag to rotate, wheel to zoom";
}
SDL_SetWindowTitle(window_, title.c_str());
}
void drawFrame() const {
glColor3f(0.20f, 0.27f, 0.38f);
glBegin(GL_LINES);
for (int xSide = 0; xSide <= 1; ++xSide) {
for (int zSide = 0; zSide <= 1; ++zSide) {
const float x = xSide ? WIDTH : 0.0f;
const float z = zSide ? DEPTH : 0.0f;
glVertex3f(x, 0.0f, z);
glVertex3f(x, HEIGHT, z);
}
}
for (int ySide = 0; ySide <= 1; ++ySide) {
const float y = ySide ? HEIGHT : 0.0f;
glVertex3f(0.0f, y, 0.0f);
glVertex3f(WIDTH, y, 0.0f);
glVertex3f(0.0f, y, DEPTH);
glVertex3f(WIDTH, y, DEPTH);
glVertex3f(0.0f, y, 0.0f);
glVertex3f(0.0f, y, DEPTH);
glVertex3f(WIDTH, y, 0.0f);
glVertex3f(WIDTH, y, DEPTH);
}
glColor3f(0.12f, 0.17f, 0.25f);
for (int x = 0; x <= WIDTH; ++x) {
glVertex3f(static_cast<float>(x), 0.01f, 0.0f);
glVertex3f(static_cast<float>(x), 0.01f, DEPTH);
}
for (int y = 0; y <= DEPTH; ++y) {
glVertex3f(0.0f, 0.01f, static_cast<float>(y));
glVertex3f(WIDTH, 0.01f, static_cast<float>(y));
}
glEnd();
}
void drawBlock(int x, int y, int z, int type) const {
const auto& color = COLORS[static_cast<std::size_t>(type)];
const float x0 = static_cast<float>(x) + 0.04f;
const float x1 = static_cast<float>(x + 1) - 0.04f;
const float y0 = static_cast<float>(z) + 0.04f;
const float y1 = static_cast<float>(z + 1) - 0.04f;
const float z0 = static_cast<float>(y) + 0.04f;
const float z1 = static_cast<float>(y + 1) - 0.04f;
const std::array<std::array<float, 3>, 8> v = {{
{{x0, y0, z0}}, {{x1, y0, z0}}, {{x1, y1, z0}}, {{x0, y1, z0}},
{{x0, y0, z1}}, {{x1, y0, z1}}, {{x1, y1, z1}}, {{x0, y1, z1}},
}};
const std::array<std::array<int, 4>, 6> faces = {{
{{0, 1, 2, 3}}, {{5, 4, 7, 6}}, {{4, 0, 3, 7}},
{{1, 5, 6, 2}}, {{3, 2, 6, 7}}, {{4, 5, 1, 0}},
}};
const std::array<float, 6> shade = {{0.62f, 0.78f, 0.70f,
0.82f, 1.0f, 0.52f}};
glBegin(GL_QUADS);
for (std::size_t face = 0; face < faces.size(); ++face) {
glColor3f(color[0] * shade[face],
color[1] * shade[face],
color[2] * shade[face]);
for (int vertex : faces[face]) {
const auto& point = v[static_cast<std::size_t>(vertex)];
glVertex3f(point[0], point[1], point[2]);
}
}
glEnd();
}
void draw() {
int width = 0;
int height = 0;
SDL_GL_GetDrawableSize(window_, &width, &height);
if (height == 0) {
return;
}
glViewport(0, 0, width, height);
glClearColor(0.035f, 0.05f, 0.085f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
const float aspect = static_cast<float>(width) / height;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
const double halfHeight = 0.1;
glFrustum(-halfHeight * aspect, halfHeight * aspect,
-halfHeight, halfHeight, 0.1, 100.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -cameraDistance_);
glRotatef(cameraPitch_, 1.0f, 0.0f, 0.0f);
glRotatef(cameraYaw_, 0.0f, 1.0f, 0.0f);
glTranslatef(-WIDTH / 2.0f, -HEIGHT / 2.0f, -DEPTH / 2.0f);
drawFrame();
for (int z = 0; z < HEIGHT; ++z) {
for (int y = 0; y < DEPTH; ++y) {
for (int x = 0; x < WIDTH; ++x) {
const int type = board_[z][y][x];
if (type != 0) {
drawBlock(x, y, z, type - 1);
}
}
}
}
if (!gameOver_) {
for (const Cell& cell : piece_.cells) {
drawBlock(x_ + cell.x, y_ + cell.y, z_ + cell.z, pieceType_);
}
}
SDL_GL_SwapWindow(window_);
}
};
} // namespace
int main(int argc, char* argv[]) {
if (argc > 1 && std::string(argv[1]) == "--version") {
std::cout << "3D Tetris " << GAME_VERSION << '\n';
return 0;
}
if (argc > 1 && std::string(argv[1]) == "--help") {
std::cout << "3D Tetris " << GAME_VERSION
<< "\nControls: arrows or WASD move, Q/E rotate, Space drop, "
"Down soft-drops, P pauses, R restarts. Drag to rotate "
"the camera and use the mouse wheel to zoom.\n";
return 0;
}
try {
Game game;
game.run();
} catch (const std::exception& error) {
std::cerr << error.what() << '\n';
return 1;
}
return 0;
}
Loading…
Cancel
Save