major refactor

compile_commands.json

@@ -1 +0,0 @@
-compile_commands.json

include/elements.hpp

@@ -1,31 +1,42 @@
 #ifndef ELEMENTS_HPP
 #define ELEMENTS_HPP
 
-struct Point {
+#include "globals.hpp"
-	Point();
+
-	int m_row;
+enum Direction {
-	int m_col;
+	NONE = 0,
-	void assign(int row, int col);
+	UP = -1,
+	DOWN = 1
 };
 
+struct Point {
+	Point() : m_row(0), m_col(0) {};
+	Point(int r, int c, char s) : m_row(r), m_col(c), m_symbol(s) {};
+	int m_row;
+	int m_col;
+	char m_symbol;
+};
+
+
 struct Ball {
-	Ball();
+	Ball() : m_vx(1), m_vy(-1) {};
-	Point m_origin;
+	Point* m_origin;
 	int m_vx;
 	int m_vy;
-	bool m_goal;
+	bool determine_next_valid_position(Point* (*board)[COL]);
-	void get_new_pos();
-	void check_collision();
-	void change_direction(char d);
 };
 
 struct Paddle {
-	Paddle(int col);
+	Paddle() : m_score(0) {};
-	int _size;
 	int m_score;
-	Point m_nodes[3];
+	int m_size;
-	void get_new_pos(int col);
+	Point** m_nodes;
-	void check_collision(Ball &ball);
+	enum Direction m_dir;
+	void determine_new_position(Point* (*board)[COL]);
 };
 
+void on_collision_with_ball(Point** segments, Ball &ball, int t_size);
+Ball create_ball(Point** segments, int row, int col, char symbol, int t_size);
+Paddle create_paddle(Point** segments, int starting_index, int ending_index, int column, char symbol);
+
 #endif

include/input.hpp

@@ -3,8 +3,8 @@
 #include "elements.hpp"
 
 struct Input {
-	char m_getch = ' ';
+	int m_getch = 0;
-	void get_input(bool &r, Paddle &a, Paddle &b);
+	void get_input(enum Direction &left, enum Direction &right, bool &running);
 };
 
 #endif // INPUT_HPP

include/timer.hpp

@@ -2,7 +2,7 @@
 #define TIMER_HPP
 
 struct Timer {
-	void decrement_time(int &time, bool &running, bool &timer_active);
+	void decrement_time(int &time, bool &running);
 };
 
 #endif

include/window.hpp

@@ -1,12 +1,13 @@
 #ifndef WINDOW_HPP
 #define WINDOW_HPP
 
-#include <array>
 #include "globals.hpp"
 #include "elements.hpp"
 
 struct Window {
-	std::array<std::array<char, COL>, ROW> m_board = {};
+	Point* m_board[ROW][COL] = {};
-	void update_display(Paddle &left, Paddle &right, Ball &ball, int &time);
+	void clear_display();
+	void draw_display(int milliseconds);
+	void update_display(Point** segments);
 };
 #endif

src/elements.cpp

@@ -1,58 +1,68 @@
 #include "elements.hpp"
 #include "globals.hpp"
 
-Point::Point() {
+Ball create_ball(Point** segments, int row, int col, char symbol, int t_size) {
-	m_col = m_row = 0;
+	Ball ball;
+	segments[t_size - 1] = new Point { row, col, symbol };
+	ball.m_origin = segments[t_size - 1];
+	return ball;
 }
 
-void Point::assign(int row, int col) {
+Paddle create_paddle(Point** segments, int starting_index, int ending_index, int column, char symbol) {
-	m_row = row;
+	Paddle paddle;
-	m_col = col;
+	paddle.m_size = ending_index - starting_index;
+	paddle.m_nodes = new Point*[paddle.m_size];
+	int starting_y_index = (ROW / 2) - (paddle.m_size / 2);
+	for(int i = 0; i < paddle.m_size; i++) {
+		paddle.m_nodes[i] = new Point { starting_y_index + i, column, symbol };
+		segments[starting_index + i] = paddle.m_nodes[i];
+	}
+	return paddle;
 }
 
-Paddle::Paddle(int col) {
+void Paddle::determine_new_position(Point* (*board)[COL]) {
-	_size = 3;
+	if(m_dir == UP) {
-	m_score = 0;
+		if(board[(m_nodes[0]->m_row) - 1][m_nodes[0]->m_col] == nullptr) {
-	for(int i = 0; i < _size; i++) { m_nodes[i].assign(i + (_size * 2), col); }
+			for(int i = 0; i < m_size; i++) {
+				m_nodes[i]->m_row--;
+			}
+		}
+	} else if(m_dir == DOWN) {
+		if(board[(m_nodes[m_size - 1]->m_row) + 1][m_nodes[m_size - 1]->m_col] == nullptr) {
+			for(int i = 0; i < m_size; i++) {
+				m_nodes[i]->m_row++;
+			}
+		}
+	}
+	m_dir = NONE;
 }
 
-void Paddle::get_new_pos(int col) {
+void on_collision_with_ball(Point** segments, Ball &ball, int t_size) {
-	for(int i = 1; i < _size; i++) { m_nodes[i].assign(m_nodes[0].m_row + i, col); }
+	for(int i = 0; i < t_size - 1; i++) {
-}
+		if(segments[i]->m_row != ball.m_origin->m_row) continue; 
-
+		if(segments[i]->m_col != ball.m_origin->m_col) continue;
-void Paddle::check_collision(Ball &ball) {
+		if (ball.m_vx == 1) ball.m_vx = -1;
-	for(int i = 0; i < _size; i++) {
+		else ball.m_vx = 1;
-		if(ball.m_origin.m_row == m_nodes[i].m_row && ball.m_origin.m_col == m_nodes[i].m_col) {
-			ball.change_direction('x');
-		}
 	}
 }
 
-Ball::Ball() {
+bool Ball::determine_next_valid_position(Point* (*board)[COL]) {
-	m_origin.assign((ROW / 2), (COL / 2));
+	if(m_origin->m_row <= 0 || m_origin->m_row >= ROW - 1) {
-	m_vx = 1;
-	m_vy = -1;
-	m_goal = false;
-}
-
-void Ball::change_direction(char d) {
-	if(d == 'y') {
 		if (m_vy == 1) m_vy = -1;
 		else m_vy = 1;
-	} if(d == 'x') {
-		if (m_vx == 1) m_vx = -1;
-		else m_vx = 1;
 	}
+	if(m_origin->m_col <= 0 || m_origin->m_col >= COL - 1) return false;
+	if(m_vx == 1) {
+		m_origin->m_col++;
 	}
-
+	else if(m_vx == -1) {
-void Ball::check_collision() {
+		m_origin->m_col--;
-	if(m_origin.m_row <= 0 || m_origin.m_row >= ROW - 1) change_direction('y');
-	if(m_origin.m_col <= 0 || m_origin.m_col >= COL - 1) m_goal = true;
 	}
-
+	if(m_vy == 1) {
-void Ball::get_new_pos() {
+		m_origin->m_row++;
-	if(m_vx == 1) m_origin.m_col++;
+	}
-	else if(m_vx == -1) m_origin.m_col--;
+	else if(m_vy == -1) {
-	if(m_vy == 1) m_origin.m_row++;
+		m_origin->m_row--;
-	else if(m_vy == -1) m_origin.m_row--;
+	}
+	return true;
 }

src/input.cpp

@@ -1,39 +1,24 @@
-#include "globals.hpp"
 #include "input.hpp"
+#include <iostream>
 #include <ncurses.h>
 
-void Input::get_input(bool &running, Paddle &a, Paddle &b) {
+void Input::get_input(enum Direction &left, enum Direction &right, bool &running) {
 	while(running) {
 		initscr();
 		cbreak();
 		noecho();
 
 		m_getch = getch();
-
 		endwin();
-		if(m_getch == 'w') {
+
-			if(a.m_nodes[0].m_row > 0) {
+		if(m_getch == 119) left = UP;
-				a.m_nodes[0].m_row--;
+		else if(m_getch == 115) left = DOWN;
-				m_getch = ' ';
+
-			}
+		if(m_getch == 65) right = UP;
-		} else if(m_getch == 's') {
+		else if(m_getch == 66) right = DOWN;
-			if(a.m_nodes[a._size - 1].m_row < ROW - 1) {
+
-				a.m_nodes[0].m_row++;
+		if(m_getch == 113) running = false;
-				m_getch = ' ';
+
-			}
+		m_getch = 0;
-		} if(m_getch == 'A') {
-			if(b.m_nodes[0].m_row > 0) {
-				b.m_nodes[0].m_row--;
-				m_getch = ' ';
-			}
-		} else if(m_getch == 'B') {
-			if(b.m_nodes[b._size - 1].m_row < ROW - 1) {
-				b.m_nodes[0].m_row++;
-				m_getch = ' ';
-			}
-		}
-		if(m_getch == 'q') {
-			running = false;
-		}
 	}
 }

src/main.cpp

@@ -7,48 +7,55 @@
 #include "globals.hpp"
 
 int main() {
-	bool running = true;
+	int time_seconds = 5;
 	Input input;
 	Timer timer;
 	Window window;
-	Paddle left(1);
+	bool running = true;
-	Paddle right(COL - 2);
+	Point* segments[8] = {};
-	Ball ball;
+
-	int time = 90;
+	Paddle left = create_paddle(segments, 0, 3, 1, '|');
-	bool timer_active = true;
+	Paddle right = create_paddle(segments, 3, 6, COL - 2, '|');
-	std::thread timer_thread(&Timer::decrement_time, &timer, std::ref(time), std::ref(running), std::ref(timer_active));
+	Ball ball = create_ball(segments, (ROW / 2), (COL / 2), 'o', 8);
-	std::thread input_thread(&Input::get_input, &input, std::ref(running), std::ref(left), std::ref(right));
+
+	std::thread timer_thread([&] { timer.decrement_time(time_seconds, running); } );
+	std::thread input_thread([&] { input.get_input(left.m_dir, right.m_dir, running); } );
+
 	while (running) {
-		window.update_display(left, right, ball, time);
+		left.determine_new_position(window.m_board);
-		left.get_new_pos(1);
+		right.determine_new_position(window.m_board);
-		right.get_new_pos(COL - 2);
+		if(!ball.determine_next_valid_position(window.m_board)) {
-		ball.get_new_pos();
+			if(ball.m_origin->m_col < 1) {
-		ball.check_collision();
-		left.check_collision(ball);
-		right.check_collision(ball);
-		if (ball.m_goal && ball.m_origin.m_col < (ROW / 2)) {
-			ball.m_goal = false;
-			right.m_score++;
-			ball.m_origin.assign(5, 10);
-		} else if(ball.m_goal && ball.m_origin.m_col > (ROW / 2)) {
-			ball.m_goal = false;
 				left.m_score++;
-			ball.m_origin.assign(5, 10);
+			} else if(ball.m_origin->m_col > COL - 2) {
+				right.m_score++;
 			}
-		if(!timer_active) {
+			ball.m_origin->m_row = ROW / 2;
-			std::cout << "\033[H" << std::flush; // Clear screen
+			ball.m_origin->m_col = COL / 2;
+		}
+		on_collision_with_ball(segments, ball, 7);
+		if(time_seconds <= 0) {
 			if(left.m_score > right.m_score) {
-				std::cout << "Player 1 wins!" << std::endl; 
+				std::cout << "Player 1 wins!\n"; 
 			} if(left.m_score < right.m_score) {
-				std::cout << "Player 2 wins!" << std::endl; 
+				std::cout << "Player 2 wins!\n"; 
 			} if(left.m_score == right.m_score) {
-				std::cout << "It's a tie!" << std::endl; 
+				std::cout << "It's a tie!\n";
 			}
 			running = false;
 		}
+		window.clear_display();
+		window.update_display(segments);
+		window.draw_display(130);
+		std::cout << "Time left: " << time_seconds << ", Score ( " << left.m_score << " : " << right.m_score << " )\n";
 	}
 
 	timer_thread.join();
 	input_thread.join();
+	for(int i = 8; i > 0; i--) {
+		if(segments[i] != nullptr) {
+			delete segments[i];
+		}
+	}
 	return 0;
 }

src/timer.cpp

@@ -2,13 +2,9 @@
 #include <chrono>
 #include "timer.hpp"
 
-void Timer::decrement_time(int &time, bool &running, bool &timer_active) {
+void Timer::decrement_time(int &time, bool &running) {
 	while (running) {
 		std::this_thread::sleep_for(std::chrono::seconds(1));
 		time--;
-		if(time <= 0) {
-			timer_active = false;
 	}
 }
-
-}

src/window.cpp

@@ -3,20 +3,29 @@
 #include <chrono>
 #include <thread>
 
-void Window::update_display(Paddle &left, Paddle &right, Ball &ball, int &time) {
+void Window::clear_display() {
-	for(std::array<char, COL> &row : m_board) { row.fill('.'); }
+	for(int i = 0; i < ROW; i++) {
-	for(int i = 0; i < left._size; i++) {
+		for(int j = 0; j < COL; j++) {
-		m_board[left.m_nodes[i].m_row][left.m_nodes[i].m_col] = '|';
+			m_board[i][j] = nullptr;
-		m_board[right.m_nodes[i].m_row][right.m_nodes[i].m_col] = '|';
 		}
-	m_board[ball.m_origin.m_row][ball.m_origin.m_col] = '*';
+	}
-	std::cout << "\033[H" << std::flush; // Clear screen
+}
-	for(std::array<char, COL> &row : m_board) {
+
-		for(char &col : row) {
+void Window::draw_display(int milliseconds) {
-			std::cout << col << " ";
+	for(int i = 0; i < ROW; i++) {
+		for(int j = 0; j < COL; j++) {
+			if(m_board[i][j] == nullptr) std::cout << ". ";
+			else std::cout << m_board[i][j]->m_symbol << " ";
 		}
 		std::cout << "\r\n";
 	}
-	std::cout << "Time left: " << time << ", Score ( " << left.m_score << " : " << right.m_score << " )" << std::endl;
+	std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds)); // 1000 / fps; 200ms = 5fps
-	std::this_thread::sleep_for(std::chrono::milliseconds(130)); // 1000 / fps; 200ms = 5fps
+}
+
+void Window::update_display(Point** segments) {
+	std::cout << "\033[H" << std::flush; // Clear screen
+	for(int i = 10; i >= 0; i--) {
+		if(segments[i] == nullptr) continue;
+		m_board[segments[i]->m_row][segments[i]->m_col] = segments[i];
+	}
 }