Итоговый PR: mouseartiom

.gitignore

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

database/items_data.cpp

@@ -0,0 +1,151 @@
+#include "session_data.h"
+// #include "event_factory.h"
+#include "mapscanner.h"
+#include <algorithm>
+#include <vector>
+
+using std::vector;
+using namespace SessionData;
+
+//---------------------------------------------------------
+//----------------- EventsData ----------------------------
+//---------------------------------------------------------
+
+bool EventsData::Init() {
+    EventFactory eFactory;
+    str path = systemData.resourcesDirectory + systemData.nextLocationName + "/events";
+    eFactory.InitAll(path, currentEventList); // hardcoded just for debugging
+    // using unique_ptr for two-dim array isn't a good idea though
+    // std::unique_ptr<Event[][]> eventMatrix (nullptr); 
+
+    eventMatrix = new std::vector<Event>** [gameData.mapHeight];
+    for (int i = 0; i != gameData.mapHeight; i++) {
+        eventMatrix[i] = new std::vector<Event>*;
+        for (int j = 0; j != gameData.mapWidth; j++) {
+        eventMatrix[i][j] = NULL;
+        }
+    }
+
+    PulverizeEvents(currentEventList); 
+    return true;
+}
+
+Event* EventsData::getEvent(const str key) {
+    return &currentEventList.at(key);
+}
+
+Event* EventsData::getEvent(Coord point) {
+    if (!surfaceData.CoordIsValid(point)) return NULL;
+    if (!eventMatrix[point.x][point.y]) return NULL;
+    auto ev = eventMatrix[point.x][point.y];
+    if (!eventMatrix[point.x][point.y]->empty()) 
+        return &eventMatrix[point.x][point.y]->front();
+    else return NULL;
+}
+
+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 width = gameData.mapWidth;
+        int height = gameData.mapHeight;
+
+        Coord eventCenter = event.GetCoord();
+        if (eventCenter.x > width || eventCenter.y > height) throw "coordinates are out of range";
+        if (eventCenter.x < 0 || eventCenter.y < 0) throw "invalid coordinates";
+
+        for (int i = eventCenter.x - event.getRadius(); i <= eventCenter.x + event.getRadius(); i++) {
+            for (int j = eventCenter.y - event.getRadius(); j <= eventCenter.y + event.getRadius(); j++) {
+
+                if (
+                    eventCenter.y + event.getRadius() > height ||
+                    eventCenter.x + event.getRadius() > width  ||
+                    eventCenter.y - event.getRadius() < 0      ||
+                    eventCenter.x - event.getRadius() < 0      
+                ) break; //total size of event mark exceeded the map
+
+                // if (!SurfaceMap::getSurface(eventCenter)) break;
+
+                if (!eventMatrix[eventCenter.x][eventCenter.y]) {
+                    eventMatrix[eventCenter.x][eventCenter.y] = new std::vector<Event>;
+                eventMatrix[eventCenter.x][eventCenter.y]->push_back(event);
+                }
+                else {
+                    eventMatrix[eventCenter.x][eventCenter.y]->push_back(event);  
+
+                    std::push_heap( // SIC! that wasn't tested
+                        eventMatrix[eventCenter.x][eventCenter.y]->begin(),
+                        eventMatrix[eventCenter.x][eventCenter.y]->end(),
+                        [](Event& a, Event& b) {
+                            return a.getPriority() < b.getPriority();
+                            }
+                        );
+                }
+            }
+        }
+    }
+}
+
+void EventsData::RemoveFrontEvent(Coord point) {
+    Event* event = getEvent(point);
+    Coord center = event->GetCoord();
+    int radius = event->getRadius();
+
+    for (int i = center.x - radius ; i < center.x + radius; i++) {
+        for (int j = center.y - radius ; j < center.y + radius; j++) {
+            if ( surfaceData.CoordIsValid( {i, j} ) ) {
+                std::pop_heap(eventMatrix[i][j]->begin(), 
+                eventMatrix[i][j]->end(),
+                [](Event& a, Event& b) {
+                    return a.getPriority() < b.getPriority();
+                } );
+            };
+        }
+    }
+}
+
+bool EventsData::EventExists(str ID) {
+    return currentEventList.count(ID);
+}
+
+//---------------------------------------------------------
+//---------------- ArtifactsData --------------------------
+//---------------------------------------------------------
+
+bool ArtifactsData::Init() {
+    ArtifactFactory aFactory;
+    str path = systemData.resourcesDirectory + systemData.nextLocationName + "/artifacts";
+    aFactory.InitAll(path, currentArtifactsList);
+    return true;
+}
+
+Artifact* ArtifactsData::getArtifact(const str key) {
+    return &currentArtifactsList.at(key);
+}
+
+bool ArtifactsData::ArtifactExists(str ID) {
+    return currentArtifactsList.count(ID);
+}
+
+//---------------------------------------------------------
+//--------------------- GameData --------------------------
+//---------------------------------------------------------
+
+
+
+//---------------------------------------------------------
+//--------------------- SystemData ------------------------
+//---------------------------------------------------------
+
+SystemData::SystemData(str _nextLocationName)
+: 
+resourcesDirectory("resources/"), 
+nextLocationName(_nextLocationName), 
+mapName("map") {
+
+}

database/items_data.h

@@ -0,0 +1,57 @@
+#ifndef ITEMSDATA
+#define ITEMSDATA
+
+#include <string>
+#include <unordered_map>
+
+#include "hero.h"
+#include "event_factory.h"
+#include "artifact.h"
+// #include "artifact_factory.h"
+#include "surface.h" //here is SurfaceData, temporary solution.
+
+class SystemData {
+public:
+    SystemData(str nextLocationName = "default_location");
+    str resourcesDirectory; // directory with all the resources
+    str nextLocationName; // ID of a map going to be loaded
+    str currentLocationName; // ID of a map loaded
+    str mapName; // name of the .bmp file
+};
+
+class GameData {
+// stores finished events and other stuff
+public:
+    int mapHeight;
+    int mapWidth;
+    str diaryString; // what we are writin'
+    str character;  // who is writin'
+};
+
+class EventsData {
+public:
+    bool Init();
+    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
+    std::vector<Event> ***eventMatrix;
+    // std::unique_ptr<Event[][]> eventMatrix;
+    std::unordered_map<str, Event> currentEventList;
+    // std::unordered_map<str, Event> globalEventList;
+};
+
+class ArtifactsData {
+public:
+    bool Init();
+    bool ArtifactExists(str);
+    Artifact* getArtifact(const str);
+private:
+    std::unordered_map<str, Artifact> currentArtifactsList;
+    // std::unordered_map<str, Artifact> globalArtifactsList;
+};
+
+#endif //SESSION

database/session_data.cpp

@@ -0,0 +1,20 @@
+#include "session_data.h"
+#include <iostream>
+
+namespace SessionData {
+    SystemData systemData;
+    GameData gameData;
+    SurfaceData surfaceData;
+    EventsData eventsData;
+    ArtifactsData artifactsData;
+
+    str diaryString;
+    str writer;
+
+    // hero initialization
+    std::string name = "Moleque";
+    std::string id = "super_hero";
+    Coord start(200, 200);
+    Hero hero(id, name, 1, 10, start);
+}
+

database/session_data.h

@@ -0,0 +1,19 @@
+#ifndef SESSIONDATA
+#define SESSIONDATA
+
+#include "items_data.h"
+
+namespace SessionData {
+    extern SurfaceData surfaceData;
+    extern GameData gameData;
+    extern SystemData systemData;
+    extern ArtifactsData artifactsData;
+    // extern CreatureData creatureData;
+    extern EventsData eventsData;
+    // hero initialization
+    extern Hero hero;
+    extern str diaryString;
+    extern str writer;
+}
+
+#endif // SESSIONDATA