Итоговый PR: mouseartiom

.gitignore

@@ -0,0 +1,8 @@
+*.[oa]
+*vgcore*
+.vscode/**
+*.txt
+*.out
+*.exe
+*test*
+*.gch

configs/config.h

@@ -0,0 +1,11 @@
+/* sometimes it will be a beautiful yaml config... */
+
+#ifndef CONFIGURATION
+#define CONFIGURATION
+
+const int step_delay = 1000000;
+const int timer_delay = 50;
+const int hero_icon_size = 50;
+const int hero_offset = hero_icon_size/2;
+
+#endif  // CONFIGURATION

database/items_data.cpp

@@ -0,0 +1,163 @@
+#include <algorithm>
+#include <vector>
+
+#include "session_data.h"
+// #include "event_factory.h"
+#include "artifact_factory.h"
+#include "mapscanner.h"
+#include "config.h"
+
+using namespace SessionData;
+using std::vector;
+using std::cout;
+
+//---------------------------------------------------------
+//----------------- EventsData ----------------------------
+//---------------------------------------------------------
+
+EventsData::EventsData() 
+: eventMatrix(gameData.mapWidth, gameData.mapHeight, true) {
+    EventFactory eFactory;
+    eFactory.InitAll(systemData.eventsPath.u8string(), currentEventList); 
+    PulverizeEvents(currentEventList);
+}
+
+EventsData::~EventsData() {
+    Coord temp;
+    int counter = 0;
+    for (temp.y = 0; temp.y < eventMatrix.getHeight(); temp.y++) {
+        for (temp.x = 0; temp.x < eventMatrix.getHeight(); temp.x++) {
+            if (eventMatrix[temp]) {
+                counter++;
+                delete eventMatrix[temp];
+            }
+        }
+    }
+    cout << counter << " events were deleted by destructor" << endl;
+}
+
+Event* EventsData::getEvent(const str key) {
+    return &currentEventList.at(key);
+}
+
+Event* EventsData::getEvent(Coord point) {
+    if (!surfaceData.CoordIsValid(point)) return NULL;
+    if (!eventMatrix[point]) return NULL;
+    if (!eventMatrix[point]->empty()) 
+        // return eventMatrix[point]->front();
+        return getEvent(eventMatrix[point]->front());
+    else return NULL;
+}
+
+bool ComparePriorities(str lvalue, str rvalue) {
+    Event* left = eventsData.getEvent(lvalue);
+    Event* right = eventsData.getEvent(rvalue);
+    return left->getPriority() < right->getPriority();
+};
+
+void EventsData::PulverizeEvents(std::unordered_map<str, Event>& list) {
+/* 
+parsing map - getting event and spraying it at the map. 
+get event
+add event to map
+*/
+    for (auto i : list) {
+        Event &event = i.second;
+        int counter = 0;
+
+        Coord eventCenter = event.GetCoord();
+        Coord current;
+
+        for (current.x = eventCenter.x - event.getRadius();
+        current.x <= eventCenter.x + event.getRadius();
+        current.x++) {
+            for (current.y = eventCenter.y - event.getRadius(); 
+            current.y <= eventCenter.y + event.getRadius(); 
+            current.y++) {
+                counter++;
+                if (!eventMatrix[current]) {
+                    eventMatrix[current] = new std::vector<str>;
+                    eventMatrix[current]->push_back(event.GetId());
+                } else {
+                    eventMatrix[current]->push_back(event.GetId());  
+                    std::push_heap(
+                        eventMatrix[current]->begin(),
+                        eventMatrix[current]->end(),
+                        ComparePriorities
+                    );
+                }
+            }
+        }
+        cout << "event " << event.GetName() << " was sprayed " << counter << " times" << endl;
+    }
+}
+
+void EventsData::RemoveFrontEvent(Coord point) {
+    Event* event = getEvent(point);
+    if (!event) return;
+    Coord center = event->GetCoord();
+    int radius = event->getRadius();
+    int counter = 0;
+    Coord startPos;
+
+    for (startPos.x = center.x - radius; startPos.x <= center.x + radius; startPos.x++) {
+        for (startPos.y = center.y - radius; startPos.y <= center.y + radius; startPos.y++) {
+            if ( surfaceData.CoordIsValid( startPos ) ) {
+                std::pop_heap(eventMatrix[startPos]->begin(), 
+                    eventMatrix[startPos]->end(),
+                    ComparePriorities 
+                );
+                eventMatrix[startPos]->pop_back();
+                counter++;
+            };
+        }
+    }
+    cout << counter << " events were deleted" << endl;
+}
+
+bool EventsData::EventExists(str ID) {
+    return currentEventList.count(ID);
+}
+
+//---------------------------------------------------------
+//---------------- ArtifactsData --------------------------
+//---------------------------------------------------------
+
+ArtifactsData::ArtifactsData() {
+    ArtifactFactory aFactory;
+    aFactory.InitAll(systemData.artifactsPath.u8string(), currentArtifactsList); 
+}
+
+std::shared_ptr<Artifact> ArtifactsData::getArtifact(const str key) {
+    return std::make_shared<Artifact> (currentArtifactsList.at(key));
+}
+
+bool ArtifactsData::ArtifactExists(str ID) {
+    return currentArtifactsList.find(ID) != currentArtifactsList.end();
+}
+
+//---------------------------------------------------------
+//--------------------- GameData --------------------------
+//---------------------------------------------------------
+
+GameData::GameData() : hero(heroID, heroName, 1, 10, heroStart) {
+    mapHeight = surfaceData.getHeight();
+    mapWidth = surfaceData.getWidth();   
+}
+
+void GameData::WriteToDiary(str note) {
+    diaryString = note;
+}
+
+//---------------------------------------------------------
+//--------------------- SystemData ------------------------
+//---------------------------------------------------------
+
+SystemData::SystemData(str _nextLocationName)
+: nextLocationName(_nextLocationName) {
+    cout << "systemData initialized" << endl;
+    resourcesPath = resourcesDirectory;
+    artifactsPath = resourcesPath / nextLocationName / "artifacts";
+    eventsPath = resourcesPath / nextLocationName / "events";
+    mapPath = resourcesPath / nextLocationName / mapName;
+}

database/items_data.h

@@ -0,0 +1,70 @@
+#ifndef ITEMSDATA
+#define ITEMSDATA
+
+#include <string>
+#include <experimental/filesystem>
+#include <unordered_map>
+#include <memory>
+
+#include "hero.h"
+#include "event_factory.h"
+#include "artifact.h"
+#include "surface.h"
+#include "matrix.hpp"
+#include "paths.h"
+
+namespace fs = std::experimental::filesystem;
+
+class SystemData {
+public:
+    SystemData(str nextLocationName = defaultLocation);
+    fs::path resourcesPath;
+    fs::path artifactsPath;
+    fs::path eventsPath;
+    fs::path mapPath;
+
+    str nextLocationName; // ID of a map going to be loaded
+    str currentLocationName; // ID of a map loaded
+};
+
+class GameData {
+// stores finished events and other stuff
+public:
+    GameData();
+    Hero hero;
+    void WriteToDiary(str);
+    int mapHeight;
+    int mapWidth;
+    str diaryString; // what we are writin'
+    str writer;  // who is writin'
+    bool changeInventory = true;
+    bool tdWorking = false;
+};
+
+class EventsData {
+public:
+    EventsData();
+    ~EventsData();
+    Event* getEvent(const str);
+    Event* getEvent(Coord);
+    bool EventExists(str);
+    void RemoveFrontEvent(Coord);
+    // more methods coming in future
+private:
+    void PulverizeEvents(std::unordered_map<str, Event>&); //pulverizes events from eventList
+    Matrix<std::vector<str>*> eventMatrix;
+    std::unordered_map<str, Event> currentEventList;
+    // std::unordered_map<str, Event> globalEventList;
+};
+
+class ArtifactsData {
+public:
+    ArtifactsData();
+    bool ArtifactExists(str);
+    std::shared_ptr<Artifact> getArtifact(const str);
+private:
+    std::unordered_map<str, Artifact> currentArtifactsList;
+    // std::unordered_map<str, Artifact> globalArtifactsList;
+};
+
+#endif 

database/session_data.cpp

@@ -0,0 +1,10 @@
+#include "session_data.h"
+#include <iostream>
+
+namespace SessionData {
+    SystemData systemData;
+    SurfaceData surfaceData;
+    GameData gameData;
+    ArtifactsData artifactsData;
+    EventsData eventsData;
+}

database/session_data.h

@@ -0,0 +1,14 @@
+#ifndef SESSIONDATA
+#define SESSIONDATA
+
+#include "items_data.h"
+
+namespace SessionData {
+    extern SurfaceData surfaceData;
+    extern GameData gameData;
+    extern SystemData systemData;
+    extern ArtifactsData artifactsData;
+    extern EventsData eventsData;
+}
+
+#endif // SESSIONDATA