====== Tetris Take 6 ====== 作成日: 2023-07-23 (日) [[https://youtu.be/YLl0B9gTJPQ|初心者によるC++入門 #38 ブロックが積もるようにする]] {{:youtube:tetris_take6.gif|}} ==== main.cpp ==== #include #include #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; } ==== rectaux.h ==== #ifndef RECTAUX_H #define RECTAUX_H using APoint = SDL_Point; using APointF = SDL_FPoint; using PPoint = SDL_Point; #endif ==== gfxaux.h ==== #ifndef GFXAUX_H #define GFXAUX_H #include 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 ==== gfxaux.cpp ==== #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); } ==== board.h ==== #ifndef BOARD_H #define BOARD_H #include "cell.h" #include "rectaux.h" #include #include 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; 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 ==== board.cpp ==== #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(arena.x * board_->cell_width); int y = static_cast(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); } } ==== cell.h ==== #ifndef CELL_H #define CELL_H #include 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 ==== cell.cpp ==== #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(states.tx), y + static_cast(states.ty), board_->cell_width, board_->cell_height}; draw_rectangle(renderer, rect, fill_color_, outline_color_); } ==== block.h ==== #ifndef BLOCK_H #define BLOCK_H #include "cell.h" #include "rectaux.h" #include #include 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; void draw_blocks(SDL_Renderer *renderer, BlockList const &blocks, RenderStates states); #endif ==== block.cpp ==== #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); } } ==== piece.h ==== #ifndef PIECE_H #define PIECE_H #include "block.h" #include "rectaux.h" #include #include 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 ==== piece.cpp ==== #include "piece.h" #include "gfxaux.h" #include "board.h" #include "block.h" #include #include #include 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(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(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; } ==== eventprocessor.h ==== #ifndef EVENTPROCESSOR_H #define EVENTPROCESSOR_H class EventProcessor { public: EventProcessor(); void process(); bool should_quit_game() const; private: bool should_quit_; }; #endif ==== eventprocessor.cpp ==== #include "eventprocessor.h" #include 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_; } ==== keyboardstate.h ==== #ifndef KEYBOARDSTATE_H #define KEYBOARDSTATE_H #include #include 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 cur_state_; std::vector old_state_; }; #endif ==== keyboardstate.cpp ==== #include "keyboardstate.h" #include 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(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()); } ==== player.h ==== #ifndef PLAYER_H #define PLAYER_H #include #include #include class Piece; class KeyboardState; class Player { public: enum class Action { MoveLeft, MoveRight, RotateLeft, RotateRight, SoftDrop, HardDrop, }; using CommandQueue = std::queue; 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_map_; Piece *active_piece_; KeyboardState const *keyboard_; }; #endif ==== player.cpp ==== #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; } ==== Makefile ==== 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}