DarthMooMancer/pong
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

major refactor

Browse Source
This commit is contained in:
DarthMooMancer
2025-09-27 18:12:07 -04:00
parent efa2952ae2
commit 7c79f41b93
10 changed files with 156 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compile_commands.json
-1
View File
@@ -1 +0,0 @@
compile_commands.json
include/elements.hpp
+27 -16
View File
@@ -1,31 +1,42 @@
#ifndef ELEMENTS_HPP
#define ELEMENTS_HPP
struct Point {
Point();
int m_row;
int m_col;
void assign(int row, int col);
#include "globals.hpp"
enum Direction {
NONE = 0,
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();
Point m_origin;
Ball() : m_vx(1), m_vy(-1) {};
Point* m_origin;
int m_vx;
int m_vy;
bool m_goal;
void get_new_pos();
void check_collision();
void change_direction(char d);
bool determine_next_valid_position(Point* (*board)[COL]);
};
struct Paddle {
Paddle(int col);
int _size;
Paddle() : m_score(0) {};
int m_score;
Point m_nodes[3];
void get_new_pos(int col);
void check_collision(Ball &ball);
int m_size;
Point** m_nodes;
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
+2 -2
View File
@@ -3,8 +3,8 @@
#include "elements.hpp"
struct Input {
char m_getch = ' ';
void get_input(bool &r, Paddle &a, Paddle &b);
int m_getch = 0;
void get_input(enum Direction &left, enum Direction &right, bool &running);
};
#endif // INPUT_HPP
include/timer.hpp
+1 -1
View File
@@ -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
+4 -3
View File
@@ -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 = {};
void update_display(Paddle &left, Paddle &right, Ball &ball, int &time);
Point* m_board[ROW][COL] = {};
void clear_display();
void draw_display(int milliseconds);
void update_display(Point** segments);
};
#endif
src/elements.cpp
+50 -40
View File
@@ -1,58 +1,68 @@
#include "elements.hpp"
#include "globals.hpp"
Point::Point() {
m_col = m_row = 0;
Ball create_ball(Point** segments, int row, int col, char symbol, int t_size) {
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) {
m_row = row;
m_col = col;
Paddle create_paddle(Point** segments, int starting_index, int ending_index, int column, char symbol) {
Paddle paddle;
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) {
_size = 3;
m_score = 0;
for(int i = 0; i < _size; i++) { m_nodes[i].assign(i + (_size * 2), col); }
void Paddle::determine_new_position(Point* (*board)[COL]) {
if(m_dir == UP) {
if(board[(m_nodes[0]->m_row) - 1][m_nodes[0]->m_col] == nullptr) {
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) {
for(int i = 1; i < _size; i++) { m_nodes[i].assign(m_nodes[0].m_row + i, col); }
}
void Paddle::check_collision(Ball &ball) {
for(int i = 0; i < _size; i++) {
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');
}
void on_collision_with_ball(Point** segments, Ball &ball, int t_size) {
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;
if (ball.m_vx == 1) ball.m_vx = -1;
else ball.m_vx = 1;
}
}
Ball::Ball() {
m_origin.assign((ROW / 2), (COL / 2));
m_vx = 1;
m_vy = -1;
m_goal = false;
}
void Ball::change_direction(char d) {
if(d == 'y') {
bool Ball::determine_next_valid_position(Point* (*board)[COL]) {
if(m_origin->m_row <= 0 || m_origin->m_row >= ROW - 1) {
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++;
}
void Ball::check_collision() {
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;
else if(m_vx == -1) {
m_origin->m_col--;
}
void Ball::get_new_pos() {
if(m_vx == 1) m_origin.m_col++;
else if(m_vx == -1) m_origin.m_col--;
if(m_vy == 1) m_origin.m_row++;
else if(m_vy == -1) m_origin.m_row--;
if(m_vy == 1) {
m_origin->m_row++;
}
else if(m_vy == -1) {
m_origin->m_row--;
}
return true;
}
src/input.cpp
+12 -27
View File
@@ -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) {
a.m_nodes[0].m_row--;
m_getch = ' ';
}
} else if(m_getch == 's') {
if(a.m_nodes[a._size - 1].m_row < ROW - 1) {
a.m_nodes[0].m_row++;
m_getch = ' ';
}
} 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;
}
if(m_getch == 119) left = UP;
else if(m_getch == 115) left = DOWN;
if(m_getch == 65) right = UP;
else if(m_getch == 66) right = DOWN;
if(m_getch == 113) running = false;
m_getch = 0;
}
}
src/main.cpp
+34 -27
View File
@@ -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);
Paddle right(COL - 2);
Ball ball;
int time = 90;
bool timer_active = true;
std::thread timer_thread(&Timer::decrement_time, &timer, std::ref(time), std::ref(running), std::ref(timer_active));
std::thread input_thread(&Input::get_input, &input, std::ref(running), std::ref(left), std::ref(right));
bool running = true;
Point* segments[8] = {};
Paddle left = create_paddle(segments, 0, 3, 1, '|');
Paddle right = create_paddle(segments, 3, 6, COL - 2, '|');
Ball ball = create_ball(segments, (ROW / 2), (COL / 2), 'o', 8);
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.get_new_pos(1);
right.get_new_pos(COL - 2);
ball.get_new_pos();
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.determine_new_position(window.m_board);
right.determine_new_position(window.m_board);
if(!ball.determine_next_valid_position(window.m_board)) {
if(ball.m_origin->m_col < 1) {
left.m_score++;
ball.m_origin.assign(5, 10);
} else if(ball.m_origin->m_col > COL - 2) {
right.m_score++;
}
if(!timer_active) {
std::cout << "\033[H" << std::flush; // Clear screen
ball.m_origin->m_row = ROW / 2;
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
+1 -5
View File
@@ -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
+21 -12
View File
@@ -3,20 +3,29 @@
#include <chrono>
#include <thread>
void Window::update_display(Paddle &left, Paddle &right, Ball &ball, int &time) {
for(std::array<char, COL> &row : m_board) { row.fill('.'); }
for(int i = 0; i < left._size; i++) {
m_board[left.m_nodes[i].m_row][left.m_nodes[i].m_col] = '|';
m_board[right.m_nodes[i].m_row][right.m_nodes[i].m_col] = '|';
void Window::clear_display() {
for(int i = 0; i < ROW; i++) {
for(int j = 0; j < COL; j++) {
m_board[i][j] = nullptr;
}
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) {
std::cout << col << " ";
}
}
void Window::draw_display(int milliseconds) {
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(130)); // 1000 / fps; 200ms = 5fps
std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds)); // 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];
}
}