wip

include/element.hpp

@@ -8,7 +8,7 @@
 
 class Window;
 
-enum Direction {
+enum class Direction {
 	UP, DOWN, LEFT, RIGHT
 };
 
@@ -29,9 +29,14 @@ public:
 private:
 	std::unique_ptr<Window> win;
 	std::vector<vec> buf;
-	bool running = true;
-	enum Direction m_dir;
-	uint8_t m_score = 0;
+	vec head { COL / 2, ROW / 2 };
+	vec fruit { rand() % COL, rand() % ROW };
+	vec prev_head { head.x, head.y };
+	struct {
+		bool running = true;
+		Direction m_dir = Direction::RIGHT;
+		uint8_t m_score = 0;
+	} state;
 	void process_input();
 	void determine_index_zero_pos();
 	void move_tail_indicies();

include/window.hpp

@@ -8,7 +8,7 @@
 struct Window {
 	std::array<std::array<char, COL>, ROW> board;
 	void draw_display();
-	void update_display(std::vector<vec> &buf);
+	void update_display(vec &head, vec &fruit, std::vector<vec> &buf);
 };
 
 #endif // WINDOW_HPP

src/element.cpp

@@ -17,9 +17,6 @@ SnakeGame::SnakeGame() {
 	noecho();
 	curs_set(0);
 	nodelay(stdscr, true);
-	buf.push_back(vec{ COL / 2, ROW / 2 });
-	buf.push_back(vec{ buf.front().x, buf.front().y });
-	buf.push_back(vec{ (rand() % COL), (rand() % ROW) });
 	win = std::make_unique<Window>();
 }
 
@@ -30,13 +27,11 @@ SnakeGame::~SnakeGame() {
 void SnakeGame::run() {
 	while (exit_summary()) {
 		process_input();
-		if(buf[FRUIT] == buf[HEAD]) {
-			add_tail_and_respawn_fruit(win->board);
-		}
+		add_tail_and_respawn_fruit(win->board);
 		determine_index_zero_pos();
 		move_tail_indicies();
 
-		win->update_display(buf);
+		win->update_display(head, fruit, buf);
 		win->draw_display();
 		std::this_thread::sleep_for(std::chrono::milliseconds((int) (200)));
 	}
@@ -46,60 +41,60 @@ void SnakeGame::process_input() {
 	int ch;
 	while((ch = getch()) != ERR) {
 		switch(ch) {
-			case 'w': if(m_dir != DOWN) m_dir = UP; break;
-			case 's': if(m_dir != UP) m_dir = DOWN; break;
-			case 'd': if(m_dir != LEFT) m_dir = RIGHT; break;
-			case 'a': if(m_dir != RIGHT) m_dir = LEFT; break;
-			case 'q': running = false; break;
+			case 'w': if(state.m_dir != Direction::DOWN) state.m_dir = Direction::UP; break;
+			case 's': if(state.m_dir != Direction::UP) state.m_dir = Direction::DOWN; break;
+			case 'd': if(state.m_dir != Direction::LEFT) state.m_dir = Direction::RIGHT; break;
+			case 'a': if(state.m_dir != Direction::RIGHT) state.m_dir = Direction::LEFT; break;
+			case 'q': state.running = false; break;
 		}
 	}
 }
 
 bool SnakeGame::exit_summary() {
-	if(!running) return false;
+	if(!state.running) return false;
 	if(buf.size() >= MAX_LEN - 1) {
-		std::cout << "You filled the whole board and won! Score: " << m_score << "\n";
+		std::cout << "You filled the whole board and won! Score: " << state.m_score << "\n";
 		return false;
 	} if(segment_overlap()) {
-		std::cout << "You collided with yourself and died! Score: " << m_score << "\n";
+		std::cout << "You collided with yourself and died! Score: " << state.m_score << "\n";
 		return false;
 	}
 	return true;
 }
 
 void SnakeGame::determine_index_zero_pos() {
-	buf.at(PREVIOUS_HEAD).set(buf[HEAD].x, buf[HEAD].y);
+	prev_head.set(head.x, head.y);
 
-	switch(m_dir) {
-		case LEFT:  buf[HEAD].x = (buf[HEAD].x + COL - 1) % COL; break;
-		case RIGHT: buf[HEAD].x = (buf[HEAD].x + 1) % COL;       break;
-		case UP:    buf[HEAD].y = (buf[HEAD].y + ROW - 1) % ROW; break;
-		case DOWN:  buf[HEAD].y = (buf[HEAD].y + 1) % ROW;       break;
+	switch(state.m_dir) {
+		case Direction::LEFT:  head.x = (head.x + COL - 1) % COL; break;
+		case Direction::RIGHT: head.x = (head.x + 1) % COL;       break;
+		case Direction::UP:    head.y = (head.y + ROW - 1) % ROW; break;
+		case Direction::DOWN:  head.y = (head.y + 1) % ROW;       break;
 	}
 }
 
 void SnakeGame::move_tail_indicies() {
-	if(buf.size() <= 3) return;
-	vec last_point = buf.back();
+	if(buf.empty()) return;
 	buf.pop_back();
-	buf.insert(buf.begin() + 3, last_point);
-	buf[3].set(buf[PREVIOUS_HEAD].x, buf[PREVIOUS_HEAD].y);
+	buf.insert(buf.begin(), prev_head);
 }
 
 void SnakeGame::add_tail_and_respawn_fruit(std::array<std::array<char, COL>, ROW> board) {
+	if(fruit != head) return;
 	int row, col;
 	do {
 		row = (rand() % ROW);
 		col = (rand() % COL);
 	} while (board[row][col] != '.');
-	buf[FRUIT].set(row, col);
-	buf.insert(buf.begin() + 3, vec { ROW, COL });
-	m_score++;
+	fruit.set(row, col);
+	buf.insert(buf.begin(), vec { ROW, COL });
+	state.m_score++;
 }
 
 bool SnakeGame::segment_overlap() {
-	for(int i : std::ranges::views::iota(3, (int)buf.size())) {
-		if(buf[i] == buf[HEAD]) return true;
+	if(buf.size() < 1) return false;
+	for(int i : std::ranges::views::iota(0, (int)buf.size())) {
+		if(buf[i] == head) return true;
 	}
 	return false;
 }

src/window.cpp

@@ -13,15 +13,12 @@ void Window::draw_display() {
 	refresh();
 }
 
-void Window::update_display(std::vector<vec> &buf) {
+void Window::update_display(vec &head, vec &fruit, std::vector<vec> &buf) {
 	for(auto& row : board) row.fill('.');
-	const auto &head = buf.at(HEAD);
 	board[head.y][head.x] = '*';
-
-	const auto &fruit = buf.at(FRUIT);
 	board[fruit.y][fruit.x] = 'o';
 
-	for(int i : std::ranges::views::iota(3, (int)buf.size())) {
+	for(int i : std::ranges::views::iota(0, (int)buf.size())) {
 		const auto &segments = buf.at(i);
 		if(segments.x < COL && segments.y < ROW) {
 			board[segments.y][segments.x] = '~';