Initial commit

Author: jae1911

.gitignore

@@ -0,0 +1,61 @@
+# C++ Build files
+build/
+Debug/
+Release/
+*.o
+*.obj
+*.out
+*.exe
+*.dll
+*.so
+*.dylib
+*.a
+*.lib
+*.lo
+*.la
+
+# CMake generated files
+CMakeFiles/
+CMakeCache.txt
+CMakeScripts/
+Testing/
+Makefile
+cmake_install.cmake
+install_manifest.txt
+compile_commands.json
+CTestTestfile.cmake
+_deps/
+*.cmake
+!CMakeLists.txt
+
+# Editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Generated documentation
+docs/generated/
+html/
+latex/
+
+# Dependency directories
+vcpkg/
+_vcpkg/
+deps/
+external/
+
+# Package files
+*.tar.gz
+*.zip
+
+# Log files
+*.log
+
+# Core dumps
+core
+
+# Cache files
+.cache/

CMakeLists.txt

@@ -0,0 +1,6 @@
+cmake_minimum_required(VERSION 3.10)
+project(CarSimulation)
+
+set(CMAKE_CXX_STANDARD 17)
+
+add_executable(CarSimulation src/main.cpp src/Road.cpp src/Vehicle.cpp)

README.md

@@ -0,0 +1,72 @@
+# Car Simulation Exercise
+
+This exercise involves simulating cars moving on a simple road network using C++ and CMake as the build tool. The goal is to model vehicles on a circular road and implement basic rules for their movement.
+
+## Features
+- **Road Network**: A circular road represented as a 1D array.
+- **Vehicle Class**: Vehicles with position, speed, and simple movement rules:
+  - Accelerate if the space ahead is clear.
+  - Decelerate if the vehicle ahead is too close.
+  - Maintain current speed otherwise.
+  - Maximum speed limit.
+- **Simulation Loop**: Updates vehicle states and prints the road state to the console.
+
+## Requirements
+- **C++ Compiler**: A C++17-compatible compiler (e.g., GCC, Clang).
+- **CMake**: Version 3.10 or higher.
+
+## Setup Instructions
+1. **Clone the repository**:
+   Open a terminal and run the following commands to clone the repository and navigate to the project folder:
+   ```bash
+   git clone https://github.com/EficodeDemoOrg/copilot-cpp-exercise
+   cd copilot-cpp-exercise
+   ```
+
+2. **Create a build directory**:
+   Create a separate directory for the build files to keep the project organized:
+   ```bash
+   mkdir build
+   cd build
+   ```
+
+3. **Run CMake to configure the project**:
+   Use CMake to generate the necessary build files:
+   ```bash
+   cmake ..
+   ```
+
+4. **Build the project**:
+   Compile the project using the generated build files:
+   ```bash
+   cmake --build .
+   ```
+
+5. **Run the simulation**:
+   Execute the compiled program to start the simulation:
+   ```bash
+   ./CarSimulation
+   ```
+
+## Output
+The simulation prints the state of the road at each step. For example:
+```
+..V.....V...........
+.....V......V.......
+.........V.......V..
+```
+Here, `.` represents an empty road cell, and `V` represents a vehicle.
+
+## Extensions
+You can extend the exercise with the following features:
+- **Intersections**: Implement a 2D grid with traffic lights or priority rules.
+- **Multiple Lanes**: Extend the road model to support multiple lanes.
+- **Different Vehicle Types**: Add cars and trucks with varying speed and acceleration profiles.
+- **Driver Behavior**: Introduce randomness in vehicle behavior.
+- **Pathfinding**: Assign destinations to vehicles in a grid network.
+- **Metrics**: Calculate average speed, throughput, and queue lengths.
+- **Visualization**: Add basic graphics or enhanced console output.
+- **OOP Refinement**: Use polymorphism for different vehicle types or intersection logic.
+
+## Notes
+This exercise is designed to be completed in approximately 2 hours and is compatible with GitHub Copilot for assistance.

src/Road.cpp

@@ -0,0 +1,32 @@
+#include "Road.h"
+#include <iostream>
+
+Road::Road(int length) : length(length) {}
+
+void Road::addVehicle(int position, int speed)
+{
+	vehicles.push_back(std::make_shared<Vehicle>(position, speed));
+}
+
+void Road::update()
+{
+	for (size_t i = 0; i < vehicles.size(); ++i) {
+		int nextPosition = vehicles[(i + 1) % vehicles.size()]->getPosition();
+		int distanceToNext = (nextPosition - vehicles[i]->getPosition() + length) % length;
+		vehicles[i]->updateSpeed(5, distanceToNext);
+	}
+
+	for (auto &vehicle : vehicles)
+		vehicle->updatePosition(length);
+}
+
+void Road::print() const
+{
+	std::vector<char> roadState(length, '.');
+	for (const auto &vehicle : vehicles)
+		roadState[vehicle->getPosition()] = 'V';
+
+	for (char cell : roadState)
+		std::cout << cell;
+	std::cout << std::endl;
+}

src/Road.h

@@ -0,0 +1,22 @@
+#ifndef ROAD_H
+#define ROAD_H
+
+#include "Vehicle.h"
+#include <vector>
+#include <memory>
+
+class Road {
+public:
+	Road(int length);
+
+	void addVehicle(int position, int speed);
+	void update();
+	void print() const;
+	const std::vector<std::shared_ptr<Vehicle>> &getVehicles() const { return vehicles; }
+
+private:
+	int length;
+	std::vector<std::shared_ptr<Vehicle>> vehicles;
+};
+
+#endif

src/Vehicle.cpp

@@ -0,0 +1,27 @@
+#include "Vehicle.h"
+#include <algorithm>
+
+Vehicle::Vehicle(int position, int speed) : position(position), speed(speed) {}
+
+int Vehicle::getPosition() const
+{
+	return position;
+}
+
+int Vehicle::getSpeed() const
+{
+	return speed;
+}
+
+void Vehicle::updateSpeed(int maxSpeed, int distanceToNext)
+{
+	if (distanceToNext > speed + 1)
+		speed = std::min(speed + 1, maxSpeed);
+	else if (distanceToNext <= speed)
+		speed = std::max(speed - 1, 0);
+}
+
+void Vehicle::updatePosition(int roadLength)
+{
+	position = (position + speed) % roadLength;
+}

src/Vehicle.h

@@ -0,0 +1,19 @@
+#ifndef VEHICLE_H
+#define VEHICLE_H
+
+class Vehicle {
+public:
+	Vehicle(int position, int speed);
+
+	int getPosition() const;
+	int getSpeed() const;
+
+	void updateSpeed(int maxSpeed, int distanceToNext);
+	void updatePosition(int roadLength);
+
+private:
+	int position;
+	int speed;
+};
+
+#endif

src/main.cpp

@@ -0,0 +1,40 @@
+#include <thread>
+#include <chrono>
+#include "Vehicle.h"
+#include "Road.h"
+#include <iostream>
+#include <vector>
+#include <iomanip>
+#include <map>
+
+int main()
+{
+	Road road(20);
+	road.addVehicle(0, 1);
+	road.addVehicle(5, 2);
+
+	int step_delay_ms = 1000;
+	int total_steps = 10;
+
+	std::cout << "Number of steps: " << total_steps << std::endl;
+
+	int padding = std::to_string(total_steps).length();
+	std::map<int, int> previous_positions;
+
+	for (int step = 0; step < total_steps; ++step) {
+		std::cout << "Step " << std::setw(padding) << (step + 1) << " of " << total_steps << ": ";
+		road.update();
+		road.print();
+
+		for (size_t i = 0; i < road.getVehicles().size(); ++i) {
+			int current_position = road.getVehicles()[i]->getPosition();
+			int previous_position = previous_positions.count(i) ? previous_positions[i] : current_position;
+			std::cout << "vehicle" << i << "(" << current_position << ") from vehicle" << i << "(" << previous_position << ")" << std::endl;
+			previous_positions[i] = current_position;
+		}
+
+		std::this_thread::sleep_for(std::chrono::milliseconds(step_delay_ms));
+	}
+
+	return 0;
+}