completed SHM-Vol.1

shm/CMakeLists.txt

@@ -0,0 +1,42 @@
+cmake_minimum_required(VERSION 3.10)
+
+set(CMAKE_C_COMPILER "/usr/bin/gcc")
+set(CMAKE_CXX_COMPILER "/usr/bin/g++")
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# set the project name
+project(SHM)
+
+# set executables
+set(THIS_PROJECT_SRC_DIRECTORIES
+)
+set(THIS_PROJECT_TESTS_DIRECTORIES
+)
+
+# set flags
+set(THIS_PROJECT_FLAGS
+    -Wall
+    -Werror 
+    -Weffc++
+    -Wextra
+    -pedantic
+    -Wconversion 
+    -O3
+)
+
+# add all executables
+add_executable(${PROJECT_NAME}
+    main.cpp
+    ${THIS_PROJECT_SRC_DIRECTORIES}
+)
+
+# specify compile options for target
+target_compile_options(${PROJECT_NAME} PRIVATE ${THIS_PROJECT_FLAGS})
+
+# enable standard cpp17
+target_compile_features(${PROJECT_NAME} PRIVATE cxx_std_17)
+
+# link ncurses static lib
+target_link_libraries(${PROJECT_NAME} ncurses)
+

shm/main.cpp

@@ -0,0 +1,20 @@
+#include <iostream>
+
+#include "source/Cargo.hpp"
+#include "source/Map.hpp"
+#include "source/Player.hpp"
+
+int main() {
+    Map();
+    Player a;
+    Player b;
+    Player c;
+
+    c.giveAwayShip();
+
+    std::cout << "\n" << a.takeOverShip(b.giveAwayShip())
+        << "\n" << b.takeOverShip(a.giveAwayShip());
+
+    std::cout << "\n\n\n";
+    return 0;
+}

shm/source/Cargo.hpp

@@ -0,0 +1,42 @@
+#pragma once
+#include <string>
+
+class Cargo {
+public:
+    Cargo(const std::string& name, const size_t amount, const size_t basePrice):
+        name_(name),
+        amount_(amount),
+        basePrice_(basePrice)
+    {}
+
+    bool operator==(const Cargo& cargo) const {
+        if (name_ != cargo.getName()) {
+            return false;
+        }
+        if (amount_ != cargo.getAmount()) {
+            return false;
+        }
+        if (basePrice_ != cargo.getBasePrice()) {
+            return false;
+        }
+        return true;    
+    }
+
+    Cargo& operator+=(size_t amount) {
+        amount_ += amount;
+        return *this;
+    }
+    Cargo& operator-=(size_t amount) {
+        amount_ -= amount;
+        return *this;
+    }
+
+    std::string getName() const { return name_; }
+    size_t getAmount() const { return amount_; }
+    size_t getBasePrice() const { return basePrice_; }
+
+protected:
+    std::string name_;
+    size_t amount_;
+    size_t basePrice_;
+};

shm/source/Fortune.hpp

@@ -0,0 +1,42 @@
+#pragma once
+#include <exception>
+#include <random>
+#include <stdexcept>
+#include <vector>
+
+struct Fortune {
+    static int getNumber(int first, int last) {
+        const int result = makeRandomNumber(first, last);
+        if (result < first || result > last) {
+            throw std::logic_error("Fortune::getNumber(int,int): Result value out of scope");
+        }
+        return result;
+    }
+
+	static std::vector<int> getNumbersEvenlyDistributed(int first, int last, const int n) {
+		if (n < 1) {
+			return {};
+		}
+		std::vector<int> result(n); 
+		for (int i = 0; i < n; ++i) {
+			int localFirst = (last / n * i) + first;
+			int localLast = (last / n * (i + 1)) + first;
+			result.at(i) = (getNumber(localFirst, localLast));
+		}
+		return result;
+	}
+
+	static void shuffle(std::vector<int>& vector) {
+		std::random_device random_device;
+        std::mt19937 random_engine(random_device());
+		std::shuffle(vector.begin(), vector.end(), random_engine);
+	}
+
+private:
+    static int makeRandomNumber(const int first, const int last) {
+        std::random_device random_device;
+        std::mt19937 random_engine(random_device());
+        std::uniform_int_distribution<int> distribution(first, last);
+        return distribution(random_engine);
+    }
+};

shm/source/Island.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+struct Island {
+	struct Coordinates {
+		int positionX;
+		int positionY;
+
+		Coordinates(const int x, const int y):
+			positionX(x),
+			positionY(y)
+		{}
+
+		bool operator==(const Coordinates& coordinates) {
+			return (positionX == coordinates.positionX && positionY == coordinates.positionY);
+		}
+	};
+
+public:
+	Island(const Coordinates& coordinates):
+		position_(coordinates)
+	{}
+
+	Coordinates getPosition() const { return position_; }
+
+private:
+	Coordinates position_;
+};

shm/source/Map.hpp

@@ -0,0 +1,63 @@
+#pragma once
+#include <algorithm>
+#include <vector>
+
+#include "Fortune.hpp"
+#include "Island.hpp"
+
+class Map {
+	size_t horizonLimit_;
+	std::vector<Island> islands_;
+	Island* currentPosition_;
+
+public:
+	Map():
+		horizonLimit_(100),
+		islands_(generateIslands(10)),
+		currentPosition_()
+	{}
+
+	Map(const Map& map):
+	 	horizonLimit_(map.horizonLimit_),
+		islands_(map.islands_),
+		currentPosition_(map.currentPosition_)	
+	{}
+
+	Map& operator=(const Map& map) {
+		horizonLimit_ = map.horizonLimit_;
+		islands_ = map.islands_;
+		currentPosition_ = currentPosition_;
+		return *this;
+	}
+
+	Island* getIsland(const Island::Coordinates& coordinate) {
+		for (auto& island : islands_) {
+			if (island.getPosition() == coordinate) {
+				return &island;
+			}
+		}
+		return nullptr;
+	}
+
+private:
+	std::vector<Island> generateIslands(const size_t numberOfIslands) const {
+		if (numberOfIslands < 1) {
+			return {};
+		}
+		auto xyPositions = generateRandomPositions(numberOfIslands);		
+		std::vector<Island> islands;
+		islands.reserve(xyPositions.size() / 2);
+		for (size_t i = 1; i < xyPositions.size(); i += 2) {
+			islands.emplace_back(Island::Coordinates(xyPositions.at(i - 1), xyPositions.at(i)));
+		}		
+		return islands;
+	}
+
+	std::vector<int> generateRandomPositions(const size_t n) const {
+		auto positions = Fortune::getNumbersEvenlyDistributed(0, static_cast<int>(horizonLimit_), static_cast<int>(n));
+		auto yPositions = Fortune::getNumbersEvenlyDistributed(0, static_cast<int>(horizonLimit_), static_cast<int>(n));
+		positions.insert(positions.end(), yPositions.begin(), yPositions.end());
+		Fortune::shuffle(positions);
+		return positions;
+	}
+};

shm/source/Player.hpp

@@ -0,0 +1,61 @@
+#pragma once
+#include <memory>
+
+#include "Ship.hpp"
+
+class Player {
+	std::unique_ptr<Ship> ship_;
+	int money_;
+	size_t availableSpace_;
+
+public:
+	Player():
+		ship_(std::make_unique<Ship>()),
+		money_(0),
+		availableSpace_()
+	{}
+
+	int getMoney() const { return money_; }
+
+	size_t getAvailableSpace() const { return availableSpace_; }
+
+	size_t getSpeed() const { 
+		if (ship_) {
+			return ship_->getSpeed();
+		}
+		return 0;
+	}
+
+	Cargo* getCargo(size_t index) const {
+		if (ship_) {
+			return ship_->getCargo(index);
+		}
+		return nullptr;
+	}
+
+	std::string takeOverShip(std::unique_ptr<Ship> someoneElsesShip) { 
+		if (!someoneElsesShip) {
+			return "there is no ship";
+		}
+		if (ship_) {
+			return "already have one";
+		}
+		ship_ = std::move(someoneElsesShip);
+		return "yarr";
+	}
+
+	std::unique_ptr<Ship> giveAwayShip() { 
+		return std::move(ship_); 
+	}
+
+	int calculateAvailableSpace() const {
+		size_t index = 0;
+		size_t count = 0;
+		auto cargo = getCargo(index);		
+		while (cargo) {
+			count += cargo->getAmount();
+			cargo = getCargo(++index);
+		}
+		return static_cast<int>(getAvailableSpace() - count);
+	}
+};

shm/source/Ship.hpp

@@ -0,0 +1,64 @@
+#pragma once
+#include <string>
+
+#include "Cargo.hpp"
+
+class Ship {
+public:
+    Ship()
+        : capacity_()
+        , maxCrew_()
+        , crew_()
+        , speed_()
+        , name_()
+        , cargo_()
+        , id_(-1)
+    {}
+
+    Ship(int capacity, int maxCrew, int speed, const std::string& name, size_t id)
+        : capacity_(capacity)
+        , maxCrew_(maxCrew)
+        , crew_(0)
+        , speed_(speed)
+        , name_(name)
+        , cargo_()
+        , id_(id)
+    {}
+
+    Ship(int maxCrew, int speed, size_t id)
+        : Ship(0, maxCrew, speed, "", id)
+    {}
+
+    void setName(const std::string& name) { name_ = name; }
+
+    Ship& operator-=(size_t num) {
+        crew_ -= num;
+        return *this;
+    }
+    Ship& operator+=(size_t num) {
+        crew_ += num;
+        return *this;
+    }
+
+    size_t getCapacity() const  { return capacity_; }
+    size_t getMaxCrew() const   { return maxCrew_; }
+    size_t getSpeed() const     { return speed_; }
+    std::string getName() const { return name_; }
+    size_t getId() const        { return id_; }
+
+    Cargo* getCargo(const size_t index) { 
+        if (index < cargo_.size()) {            
+            return &cargo_.at(index);
+        }
+        return nullptr; 
+    }
+
+private:
+    size_t capacity_;
+    size_t maxCrew_;
+    size_t crew_;
+    size_t speed_;
+    std::string name_;
+    std::vector<Cargo> cargo_;
+    const size_t id_;
+};