作成日: 2023-07-23 (日)

初心者によるC++入門 #38 ブロックが積もるようにする

#include <SDL2/SDL.h>
#include <iostream>

#include "board.h"
#include "gfxaux.h"
#include "piece.h"
#include "player.h"
#include "eventprocessor.h"
#include "keyboardstate.h"

void process_commands(Player::CommandQueue &command_queue,
                      Piece &piece,
                      BlockList const &dead_blocks) {
    while (!command_queue.empty()) {
        Player::Action action = command_queue.front();
        switch (action) {
        case Player::Action::MoveLeft:
            piece.move_left();
            if (piece.is_overlapping(dead_blocks)) {
                piece.move_right();
            }
            break;
        case Player::Action::MoveRight:
            piece.move_right();
            if (piece.is_overlapping(dead_blocks)) {
                piece.move_left();
            }
            break;
        default:
            break;
        }
        command_queue.pop();
    }
}

void process_piece_stuck(Piece &piece, BlockList &dead_blocks, APoint const &piece_spawn_position) {
    if (piece.is_stuck()) {
        piece.detach_blocks(dead_blocks);
        piece.generate_next_shape();
        piece.reset_position(piece_spawn_position);
    }
}

int main(int argc, char **argv) {
    auto *WindowTitle = "TETRIS take 6";
    int const ScreenWidth = 600;  // px
    int const ScreenHeight = 550; // px
    int const MsecsPerUpdate = 16;
    
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        std::cerr << "Error: init SDL\n";
        std::exit(1);
    }
    
    SDL_Window *window = SDL_CreateWindow(
            WindowTitle,
            SDL_WINDOWPOS_CENTERED,
            SDL_WINDOWPOS_CENTERED,
            ScreenWidth,
            ScreenHeight,
            0);
    if (window == nullptr) {
        std::cerr << "Error: create window\n";
        std::exit(1);
    }
    
    SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if (renderer == nullptr) {
        std::cerr << "Error: create renderer\n";
        std::exit(1);
    }
    
    // setup game
    BoardInfo board {
        10, 20,
        24, 24,
        SDL_Point{10, 10}
    };
    
    APoint const piece_spawn_position{3, 0};
    
    EventProcessor event_processor;
    Fence fence = setup_fence(board, Gray, White);
    CoordMediator coord_mediator{&board};
    Piece test_piece{&coord_mediator, piece_spawn_position, 0.1, 40};
    KeyboardState keyboard_state;
    Player player{&test_piece, &keyboard_state};
    player.install_action(Player::Action::MoveLeft, SDL_SCANCODE_LEFT);
    player.install_action(Player::Action::MoveRight, SDL_SCANCODE_RIGHT);
    Player::CommandQueue command_queue;
    
    BlockList dead_blocks;

    // game loop
    while (!event_processor.should_quit_game()) {
        Uint32 start = SDL_GetTicks();
        
        // process events
        event_processor.process();
        keyboard_state.update();
        
        // update
        player.update(command_queue);
        process_commands(command_queue, test_piece, dead_blocks);
        test_piece.update(dead_blocks);
        process_piece_stuck(test_piece, dead_blocks, piece_spawn_position);
        
        // render
        SDL_SetRenderDrawColor(renderer, 100, 100, 255, 255);
        SDL_RenderClear(renderer);

        draw_fence(renderer, fence);
        test_piece.draw(renderer);
        draw_blocks(renderer, dead_blocks, RenderStates{});
        
        SDL_RenderPresent(renderer);

        // synch frame rate
        Uint32 next_start = start + MsecsPerUpdate;
        Uint32 current = SDL_GetTicks();
        if (next_start >= current) {
            SDL_Delay(next_start - current);
        }
    }
    
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();

    return 0;
}

#ifndef RECTAUX_H
#define RECTAUX_H

using APoint = SDL_Point;
using APointF = SDL_FPoint;
using PPoint = SDL_Point;

#endif

#ifndef GFXAUX_H
#define GFXAUX_H

#include <SDL2/SDL.h>

SDL_Color const Gray{128, 128, 128, 255};
SDL_Color const White{255, 255, 255, 255};

void draw_rectangle(SDL_Renderer *renderer, SDL_Rect const &rect, SDL_Color const &fc, SDL_Color const &oc);

struct RenderStates {
    float tx = 0;
    float ty = 0;
};

#endif

#include "gfxaux.h"

void draw_rectangle(SDL_Renderer *renderer, SDL_Rect const &rect, SDL_Color const &fc, SDL_Color const &oc) {
    SDL_SetRenderDrawColor(renderer, fc.r, fc.g, fc.b, fc.a);
    SDL_RenderFillRect(renderer, &rect);
    SDL_SetRenderDrawColor(renderer, oc.r, oc.g, oc.b, oc.a);
    SDL_RenderDrawRect(renderer, &rect);
}

#ifndef BOARD_H
#define BOARD_H

#include "cell.h"
#include "rectaux.h"
#include <SDL2/SDL.h>
#include <vector>

struct BoardInfo {
	int arena_width;
	int arena_height;
	int cell_width;
	int cell_height;
	PPoint position;
};

class CoordMediator {
public:
    CoordMediator(BoardInfo const *board);
    PPoint arena_to_pixel(APoint const &arena) const;
    PPoint arena_to_pixel(APointF const &arena) const;
    APoint pixel_to_arena(PPoint const &pixel) const;
    PPoint arena_origin_px() const;
    int arena_top() const;
    int arena_bottom() const;
    int arena_left() const;
    int arena_right() const;

    BoardInfo const *board_info() const;

private:
    BoardInfo const *board_;
};

using Fence = std::vector<Cell>;

Fence setup_fence(BoardInfo const &board,
				  SDL_Color const &fill_color,
				  SDL_Color const &outline_color);

void draw_fence(SDL_Renderer *renderer, Fence const &fence);

#endif

#include "board.h"

#include "gfxaux.h"
#include "cell.h"

CoordMediator::CoordMediator(BoardInfo const *board)
    : board_{board}
{}

SDL_Point CoordMediator::arena_to_pixel(SDL_Point const &arena) const {
    int x = arena.x * board_->cell_width;
    int y = arena.y * board_->cell_height;
    return {x, y};
}

SDL_Point CoordMediator::arena_to_pixel(SDL_FPoint const &arena) const {
    int x = static_cast<int>(arena.x * board_->cell_width);
    int y = static_cast<int>(arena.y * board_->cell_height);
    return {x, y};
}

SDL_Point CoordMediator::pixel_to_arena(SDL_Point const &pixel) const {
    int x = pixel.x / board_->cell_width;
    int y = pixel.y / board_->cell_height;
    return {x, y};
}

SDL_Point CoordMediator::arena_origin_px() const {
    int x = board_->position.x + board_->cell_width;
    int y = board_->position.y;
    return {x, y};
}

int CoordMediator::arena_top() const {
    return 0;
}

int CoordMediator::arena_bottom() const {
    return arena_top() + board_->arena_height - 1;
}

int CoordMediator::arena_left() const {
    return 0;
}
int CoordMediator::arena_right() const {
    return arena_left() + board_->arena_width - 1;
}

BoardInfo const *CoordMediator::board_info() const {
    return board_;
}

Fence setup_fence(BoardInfo const &board,
				  SDL_Color const &fill_color,
				  SDL_Color const &outline_color) {
	Fence fence;
	
	// left wall
	for (int i{}; i < board.arena_height; ++i) {
		SDL_Point pt{0, i * board.cell_height};
		fence.emplace_back(&board, board.position, pt, fill_color, outline_color);
	}

	// right wall
	for (int i{}; i < board.arena_height; ++i) {
		SDL_Point pt{(board.arena_width + 1) * board.cell_width, i * board.cell_height};
		fence.emplace_back(&board, board.position, pt, fill_color, outline_color);
	}

	// floor
	for (int i{}; i < board.arena_width + 2; ++i) {
		SDL_Point pt{i * board.cell_width, board.arena_height * board.cell_height};
		fence.emplace_back(&board, board.position, pt, fill_color, outline_color);
	}

	return fence;
}

void draw_fence(SDL_Renderer *renderer, Fence const &fence) {
    RenderStates states{};
	for (Cell const &cell : fence) {
		cell.draw(renderer, states);
	}
}

#ifndef CELL_H
#define CELL_H

#include <SDL2/SDL.h>

struct BoardInfo;
struct RenderStates;

class Cell {
public:
    Cell(BoardInfo const *board,
         SDL_Point const &origin,
         SDL_Point const &position,
         SDL_Color const &fill_color,
         SDL_Color const &outline_color);
    ~Cell() = default;
    
    SDL_Point global_position() const;
    SDL_Point local_position() const;
    
    void draw(SDL_Renderer *renderer, RenderStates states) const;

private:
    BoardInfo const *board_;
    SDL_Point origin_;
    SDL_Point position_;
    SDL_Color fill_color_;
    SDL_Color outline_color_;
};

#endif

#include "cell.h"

#include "gfxaux.h"
#include "board.h"

Cell::Cell(BoardInfo const *board,
           SDL_Point const &origin,
           SDL_Point const &position,
           SDL_Color const &fill_color,
           SDL_Color const &outline_color)
        : board_{board}
        , origin_{origin}
        , position_{position}
        , fill_color_{fill_color}
        , outline_color_{outline_color} {
}

SDL_Point Cell::global_position() const {
    return {origin_.x + position_.x, origin_.y + position_.y};
}

SDL_Point Cell::local_position() const {
    return position_;
}

void Cell::draw(SDL_Renderer *renderer, RenderStates states) const {
    auto [x, y] = global_position();
    SDL_Rect rect{x + static_cast<int>(states.tx),
                  y + static_cast<int>(states.ty),
                  board_->cell_width, board_->cell_height};
    draw_rectangle(renderer, rect, fill_color_, outline_color_);
}

#ifndef BLOCK_H
#define BLOCK_H

#include "cell.h"
#include "rectaux.h"
#include <SDL2/SDL.h>
#include <vector>

struct RenderStates;
class CoordMediator;
class Piece;

class Block {
public:
    Block(CoordMediator const *coord_mediator,
          APoint const &position,
          SDL_Color const &fc,
          SDL_Color const &oc,
          Piece const *parent = nullptr);

    void draw(SDL_Renderer *renderer, RenderStates states) const;
    APoint local_position() const;
    APoint global_position() const;
    void detach_from_parent();

private:
    Cell cell_;
    CoordMediator const *coord_mediator_;
    APoint position_;
    Piece const *parent_;
};

using BlockList = std::vector<Block>;

void draw_blocks(SDL_Renderer *renderer, BlockList const &blocks, RenderStates states);

#endif

#include "block.h"

#include "gfxaux.h"
#include "board.h"
#include "piece.h"

namespace {
Cell create_cell(CoordMediator const *mediator,
                 SDL_Color const &fc,
                 SDL_Color const &oc) {
    auto *board = mediator->board_info();
    auto origin = mediator->arena_origin_px();
    return Cell{board, origin, APoint{0, 0}, fc, oc};
}
} // ns anon 

Block::Block(CoordMediator const *coord_mediator,
             APoint const &position,
             SDL_Color const &fc,
             SDL_Color const &oc,
             Piece const *parent)
        : cell_{create_cell(coord_mediator, fc, oc)}
        , coord_mediator_{coord_mediator}
        , position_{position}
        , parent_{parent}
{}
      
void Block::draw(SDL_Renderer *renderer, RenderStates states) const {
    SDL_FPoint tt;
    tt.x = states.tx + position_.x;
    tt.y = states.ty + position_.y;
    auto [tx, ty] = coord_mediator_->arena_to_pixel(tt);
    cell_.draw(renderer, RenderStates{float(tx), float(ty)});
}

APoint Block::local_position() const {
    return position_;
}

APoint Block::global_position() const {
    if (parent_ == nullptr) {
        return position_;
    }
    auto [px, py] = parent_->global_position();
    return {px + position_.x, py + position_.y};
}

void Block::detach_from_parent() {
    position_ = global_position();
    parent_ = nullptr;
}

void draw_blocks(SDL_Renderer *renderer, BlockList const &blocks, RenderStates states) {
    for (auto &block : blocks) {
        block.draw(renderer, states);
    }
}

#ifndef PIECE_H
#define PIECE_H

#include "block.h"
#include "rectaux.h"
#include <SDL2/SDL.h>
#include <vector>

class CoordMediator;

class Piece {
public:
    Piece(CoordMediator const *coord_mediator,
          APoint const &position,
          float falling_speed,
          unsigned stuck_delay);
    
    void draw(SDL_Renderer *renderer) const;
    APoint local_position() const;
    APoint global_position() const;
    void update(BlockList const &dead_blocks);

    bool move_left();
    bool move_right();

    bool is_stuck() const;
    void detach_blocks(BlockList &destination);
    void reset_position(APoint const &position);
    void generate_next_shape();
    bool is_overlapping(BlockList const &dead_blocks) const;

private:
    int top() const;
    int bottom() const;
    int left() const;
    int right() const;
    bool is_landing(BlockList const &dead_blocks) const;

private:
    BlockList blocks_;
    unsigned stuck_count_;
    CoordMediator const *coord_mediator_;
    APoint position_;
    float falling_speed_;
    float fy_;
    unsigned stuck_delay_;
};

#endif

#include "piece.h"

#include "gfxaux.h"
#include "board.h"
#include "block.h"
#include <cmath>
#include <cassert>
#include <algorithm>

namespace {
bool comp_block_x(Block const &a, Block const &b) {
    return a.local_position().x < b.local_position().x;
}

bool comp_block_y(Block const &a, Block const &b) {
    return a.local_position().y < b.local_position().y;
}
} // ns anon

Piece::Piece(CoordMediator const *coord_mediator,
             APoint const &position,
             float falling_speed,
             unsigned stuck_delay)
        : stuck_count_{0}
        , coord_mediator_{coord_mediator}
        , position_{}
        , falling_speed_{falling_speed}
        , fy_{}
        , stuck_delay_{stuck_delay} {
    reset_position(position);
    generate_next_shape();
}

void Piece::draw(SDL_Renderer *renderer) const {
    RenderStates states{float(position_.x), fy_};
    draw_blocks(renderer, blocks_, states);
}

APoint Piece::local_position() const {
    return position_;
}

APoint Piece::global_position() const {
    return position_;
}

void Piece::update(BlockList const &dead_blocks) {
    if (is_landing(dead_blocks)) {
        fy_ = std::trunc(fy_);
        ++stuck_count_;
    } else {
        fy_ += falling_speed_;
        position_.y = static_cast<int>(fy_);
        stuck_count_ = 0;
    }
}

bool Piece::move_left() {
    if (left() > coord_mediator_->arena_left()) {
        position_.x -= 1;
        return true;
    }
    return false;
}

bool Piece::move_right() {
    if (right() < coord_mediator_->arena_right()) {
        position_.x += 1;
        return true;
    }
    return false;
}

bool Piece::is_stuck() const {
    return stuck_count_ >= stuck_delay_;
}

void Piece::detach_blocks(BlockList &destination) {
    for (auto &block : blocks_) {
        block.detach_from_parent();
    }
    std::move(blocks_.begin(), blocks_.end(),
        std::back_inserter(destination));
    blocks_.clear();
}

void Piece::reset_position(APoint const &position) {
    position_ = position;
    fy_ = static_cast<float>(position_.y);
}

void Piece::generate_next_shape() {
    SDL_Color fc = White;
    SDL_Color oc = Gray;
    blocks_.emplace_back(coord_mediator_, APoint{0, 0}, fc, oc, this);
    blocks_.emplace_back(coord_mediator_, APoint{1, 0}, fc, oc, this);
    blocks_.emplace_back(coord_mediator_, APoint{1, 1}, fc, oc, this);
    blocks_.emplace_back(coord_mediator_, APoint{2, 1}, fc, oc, this);
}

int Piece::top() const {
    assert(!blocks_.empty());
    auto b = std::min_element(blocks_.begin(), blocks_.end(), comp_block_y);
    return b->global_position().y;
}

int Piece::bottom() const {
    assert(!blocks_.empty());
    auto b = std::max_element(blocks_.begin(), blocks_.end(), comp_block_y);
    return b->global_position().y;
}

int Piece::left() const {
    assert(!blocks_.empty());
    auto b = std::min_element(blocks_.begin(), blocks_.end(), comp_block_x);
    return b->global_position().x;
}

int Piece::right() const {
    assert(!blocks_.empty());
    auto b = std::max_element(blocks_.begin(), blocks_.end(), comp_block_x);
    return b->global_position().x;
}

bool Piece::is_landing(BlockList const &dead_blocks) const {
    if (bottom() >= coord_mediator_->arena_bottom()) {
        return true;
    }
    
    for (auto &myblock : blocks_) {
        for (auto &dead_block : dead_blocks) {
            auto [mx, my] = myblock.global_position();
            auto [dx, dy] = dead_block.global_position();
            if (mx == dx && my + 1 == dy) {
                return true;
            }
        }
    }
    
    return false;
}

bool Piece::is_overlapping(BlockList const &dead_blocks) const {
    for (auto &myblock : blocks_) {
        for (auto &dead_block : dead_blocks) {
            auto mx = myblock.global_position().x;
            auto [dx, dy] = dead_block.global_position();
            if (mx != dx) continue;
            
            float my = myblock.local_position().y + fy_;
            float diff = std::fabs(my - dy);
            if (diff < 0.6) {
                return true;
            }
        }
    }
    return false;
}

#ifndef EVENTPROCESSOR_H
#define EVENTPROCESSOR_H

class EventProcessor {
public:
    EventProcessor();
    
    void process();
    bool should_quit_game() const;
    
private:
    bool should_quit_;
};

#endif

#include "eventprocessor.h"

#include <SDL2/SDL.h>

EventProcessor::EventProcessor()
    : should_quit_{false}
{}

void EventProcessor::process() {
    SDL_Event event;
    while (SDL_PollEvent(&event)) {
        switch (event.type) {
        case SDL_QUIT:
            should_quit_ = true;
            break;
        case SDL_KEYDOWN:
            if (event.key.keysym.scancode == SDL_SCANCODE_ESCAPE) {
                should_quit_ = true;
            }
            break;
        default:
            break;
        }
    }
}

bool EventProcessor::should_quit_game() const {
    return should_quit_;
}

#ifndef KEYBOARDSTATE_H
#define KEYBOARDSTATE_H

#include <SDL2/SDL.h>
#include <vector>

class KeyboardState {
public:
    KeyboardState();
    
    void update();
    bool pressed(SDL_Scancode scancode) const;
    bool just_pressed(SDL_Scancode scancode) const;
    
private:
    void init();

private:
    std::vector<Uint8> cur_state_;
    std::vector<Uint8> old_state_;
};

#endif

#include "keyboardstate.h"

#include <algorithm>

KeyboardState::KeyboardState() {
    init();
}

void KeyboardState::update() {
    int numkeys;
    auto *state = SDL_GetKeyboardState(&numkeys);
    
    if (old_state_.size() < cur_state_.size()) {
        old_state_.resize(cur_state_.size(), 0);
    }
    std::copy(cur_state_.begin(), cur_state_.end(), old_state_.begin());
    
    if (cur_state_.size() < static_cast<size_t>(numkeys)) {
        cur_state_.resize(numkeys, 0);
    }
    std::copy(state, state + numkeys, cur_state_.begin());
}

bool KeyboardState::pressed(SDL_Scancode scancode) const {
    return cur_state_[scancode] == 1;
}

bool KeyboardState::just_pressed(SDL_Scancode scancode) const {
    return old_state_[scancode] == 0 && cur_state_[scancode] == 1;
}

void KeyboardState::init() {
    cur_state_.clear();
    old_state_.clear();
    
    int numkeys;
    auto *state = SDL_GetKeyboardState(&numkeys);
    cur_state_.resize(numkeys, 0);
    old_state_.resize(numkeys, 0);
    
    std::copy(state, state + numkeys, cur_state_.begin());
}

#ifndef PLAYER_H
#define PLAYER_H

#include <SDL2/SDL.h>
#include <map>
#include <queue>

class Piece;
class KeyboardState;

class Player {
public:
    enum class Action {
        MoveLeft,
        MoveRight,
        RotateLeft,
        RotateRight,
        SoftDrop,
        HardDrop,
    };
    
    using CommandQueue = std::queue<Action>;

    Player(Piece *piece, KeyboardState const *keyboard);
    
    void update(CommandQueue &command_queue);
    void install_action(Action action, SDL_Scancode scancode);
    
private:
    bool just_pressed(Action action) const;

private:
    std::map<Action, SDL_Scancode> action_map_;
    Piece *active_piece_;
    KeyboardState const *keyboard_;
};

#endif

#include "player.h"

#include "piece.h"
#include "keyboardstate.h"

Player::Player(Piece *piece, KeyboardState const *keyboard)
    : active_piece_{piece}
    , keyboard_{keyboard}
{
}
    
void Player::update(CommandQueue &command_queue) {
    for (auto [action, scancode] : action_map_) {
        if (keyboard_->just_pressed(scancode)) {
            command_queue.push(action);
        }
    }
}

void Player::install_action(Action action, SDL_Scancode scancode) {
    action_map_.insert({action, scancode});
}

bool Player::just_pressed(Action action) const {
    if (auto p = action_map_.find(action);
            p != action_map_.end()) {
        return keyboard_->just_pressed(p->second); 
    }
    return false;
}

SRCS = \
	main.cpp \
	board.cpp \
	gfxaux.cpp \
	cell.cpp \
    block.cpp \
    piece.cpp \
    player.cpp \
    keyboardstate.cpp \
    eventprocessor.cpp
    
OBJS = ${SRCS:%.cpp=%.o}
DEPS = ${SRCS:%.cpp=%.d}
EXECUTABLE = tetris.exe
CXXFLAGS = -std=c++20 -Wall
CPPFLAGS = -IC:\SDL2\include
LDFLAGS = -LC:\SDL2\lib
LDLIBS = -lmingw32 -lSDL2main -lSDL2

.PHONY: all
all: ${EXECUTABLE}

${EXECUTABLE}: ${OBJS}
	${CXX} -o $@ $^ ${LDFLAGS} ${LDLIBS}

%.o: %.cpp
	${CXX} -c ${CXXFLAGS} -o $@ $< -MMD -MP ${CPPFLAGS}

.PHONY: clean
clean:
	${RM} ${EXECUTABLE} ${OBJS} ${DEPS}

-include ${DEPS}