Development 4 map

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,3 @@
+Doneness checkbox:
+- [ ] Testing
+- [ ] Documentation

CMakeLists.txt

@@ -15,6 +15,11 @@ add_library(
 target_include_directories(pokemon-lib PUBLIC include)
 target_include_directories(pokemon-lib PUBLIC ${JSONCPP_INCLUDE_DIRS})
 
+add_library(
+    include/Map.h
+    src/Map.cpp
+)
+
 add_executable(pokemon src/main.cpp)
 
 target_link_libraries(pokemon PRIVATE ${JSONCPP_LIBRARIES})

Docker/README.md

@@ -1,6 +1,13 @@
 # Docker
 
-Our development philosophy with Docker is the following.
+In this project we will use docker to compile, test and run our game. It would be quite helpful to quickly check a [guide like on Docker](https://phoenixnap.com/kb/docker-image-vs-container). In this `Readme`, we explain the different steps we take to run our code inside a Docker container.
+
+### Quick overview
+1. Building Docker image with the project dependencies
+2. Development mode: Opening a shell inside the container.
+3. Test mode
+
+### Details
 
 1. We build an image that contains all the necessary dependencies to compile the application. This image only needs to be created once as long as the dependencies do not change (very rarely). **This step does not compile the game**.
     - Linux and MacOS:
@@ -10,11 +17,9 @@ Our development philosophy with Docker is the following.
     - Windows:
 
     ```$ .\Docker\windows\build_docker_image.bat```
-The image that contains the `Ubuntu-latest` environment for our application is created at this point. You can double check by running the command `$ docker images`. 
-
-2. docker run -it "pokemon-container"
+
+    At this point we have created an Docker image based on `Ubuntu-latest`. You can double check by executing `$ docker images` and hopefully find that a container called `pokemon-image`.
 
-3. Next question you should be asking yourself is: What about the source code and the compilation? The folder `Re-Pokemon-Red/Testing` will contain a script for each test that will do `docker run ...`
+2. From the root directory of our project run `$ docker run -it -v .:/pokemon_game "pokemon-image"`. This will run the docker image `"pokemon-image"` with the source code included as a [mounted volume](https://docs.docker.com/storage/volumes/). Inside this docker image you can manually compile the project as usual with: `mkdir build; cd build; cmake ..; make;`. Note: While you are developing, you can keep this shell open. Since your local machine files are synched with the docker's image thanks to `-v .:/pokemon_game`. The most comfortable workflow should be: `Write changes locally, run make in the docker image, run the program, repeat`
 
-    Step two will be much more frequent during the development process since it will be called each time we want to test our new code.
-3. 
+3. Test mode: TBD

include/Map.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "Tile.h"
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+using tileStdMap = std::map<std::pair,tile::Tile>;
+using entityStdMap = std::map<uint32_t,entity::Entity>;
+
+class Map {
+    private:
+        uint16_t id_;
+        uint8_t currentType_;
+        std::string mapName_;
+        std::string bitmapName_;
+        tileStdMap tiles_; //<Coordinates,tile>
+        entityStdMap entities_;// Map<entityId, Entity> 
+
+    public:
+
+        Map();
+        ~Map();
+        Map(uint16_t id, uint8_t currentType, std::string mapName, std::string bitmapName, tileStdMap tiles, entityStdMap entities);
+
+        bool doesItCollide(uint16_t desiredX, uint16_t desiredY, uint8_t direction);
+        bool doesItInteract(uint16_t desiredX, uint16_t desiredY, uint8_t direction);
+
+}

src/Map.cpp

@@ -0,0 +1,29 @@
+#include "Map.h"
+
+Map::Map(uint16_t id, uint8_t currentType, std::string mapName, std::string bitmapName, tileStdMap tiles, entityStdMap entities) {
+    id_ = id;
+    currentType_ = currentType;
+    mapName_ = mapName;
+    bitmapName_ = bitmapName;
+    tiles_ = tiles;
+    entities_ = entities;
+
+}
+
+Map::~Map() {
+    tiles_.clear();
+    entities_.clear();
+
+}
+
+bool Map::doesItCollide(uint16_t desiredX, uint16_t desiredY, uint8_t direction) {
+    tile::Tile tile = tiles_.at( std::pair<uint16_t,uint16_t> (desiredX, desiredY) );
+    return tile.isCollision(direction);
+
+}
+
+bool Map::doesItInteract(uint16_t desiredX, uint16_t desiredY, uint8_t direction) {
+    tile::Tile tile = tiles_.at( std::pair<uint16_t,uint16_t> (desiredX, desiredY) );
+    return tile.isInteraction(direction);
+
+}

test/MapTest.cpp

@@ -0,0 +1,38 @@
+#include "Map.h"
+
+int main() {
+    std::cout<<"hello Map"<<std::endl;
+
+    std::vector<short int> testVectorMap1  = {  9,   9,   9,   9,   9,   9,   9,   9,   9};
+    std::vector<short int> testVectorMap2  = {  9,   0,   0,   0,   0,   0,   0,   0, 100};
+    std::vector<short int> testVectorMap3  = {  9,   0,   0,   0,   0,   0,   0,   0,   9};
+    std::vector<short int> testVectorMap4  = {  9,   0,   0,   0,   0,   0,   9,  -1,   9};
+    std::vector<short int> testVectorMap5  = {  9,   0,   0,   0,   0,   0,   9,   9,   9};
+    std::vector<short int> testVectorMap6  = {  9,   0,   0,   0,   0,   0,   0,   0,   9};
+    std::vector<short int> testVectorMap7  = {  9,   0,   0,   0, 100,   9,   0,   0,   9};
+    std::vector<short int> testVectorMap8  = {  9,   0,   0,   0,   0,   0,   0, 100,   9};
+    std::vector<short int> testVectorMap9  = {  9,   0,   0,   0,   0,   0,   0, 100,   9};
+    std::vector<short int> testVectorMap10 = {  9,   0,   0,   0,   0,   0,   0,   9,   9};
+    std::vector<short int> testVectorMap11 = {  9,   0,   0, 100, 100,   0,   0,   9,   9};
+    std::vector<short int> testVectorMap12 = {  9,   0,   0,   0,   0,   0,   0, 100,   9};
+    std::vector<short int> testVectorMap13 = {  9,   9,   9,   9,   9,   9,   9,   9,   9};
+
+    std::vector<std::vector<short int>> testVectorMap;
+
+    testVectorMap.push_back(testVectorMap1);
+    testVectorMap.push_back(testVectorMap2);
+    testVectorMap.push_back(testVectorMap3);
+    testVectorMap.push_back(testVectorMap4);
+    testVectorMap.push_back(testVectorMap5);
+    testVectorMap.push_back(testVectorMap6);
+    testVectorMap.push_back(testVectorMap7);
+    testVectorMap.push_back(testVectorMap8);
+    testVectorMap.push_back(testVectorMap9);
+    testVectorMap.push_back(testVectorMap10);
+    testVectorMap.push_back(testVectorMap11);
+    testVectorMap.push_back(testVectorMap12);
+    testVectorMap.push_back(testVectorMap13);
+
+    Map testMap(testVectorMap, "testMap");
+
+}