init

src/assets.cpp

@@ -0,0 +1,11 @@
+#include "assets.hpp"
+#include "state.hpp"
+#include "texture.hpp"
+
+PhoenixTexture *PGetTextureById(int id) {
+  return &state.assets.textures.at(id);
+}
+
+void PLoadTextureAsset(std::string filePath) {
+  state.assets.textures.push_back(PLoadTexture(filePath));
+}

src/main.cpp

@@ -0,0 +1,20 @@
+#include "mapEditor.hpp"
+#include <config.hpp>
+#include <iostream>
+#include <phoenix.hpp>
+
+int main(int argc, char **argv) {
+
+  if (argc == 2) {
+    std::string arg0 = std::string(argv[1]);
+    std::cout << arg0 << std::endl;
+    if (arg0 == "-editor") {
+      runMapEditor();
+      return 0;
+    }
+  } else {
+
+    PhoenixGame *game = new PhoenixGame();
+    game->run();
+  }
+}

src/map.cpp

@@ -0,0 +1,129 @@
+#include "assets.hpp"
+#include "config.hpp"
+#include "state.hpp"
+#include "texture.hpp"
+#include <SDL.h>
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <map.hpp>
+
+std::vector<std::string> split(std::string s, std::string delimiter) {
+  size_t pos_start = 0, pos_end, delim_len = delimiter.length();
+  std::string token;
+  std::vector<std::string> res;
+
+  while ((pos_end = s.find(delimiter, pos_start)) != std::string::npos) {
+    token = s.substr(pos_start, pos_end - pos_start);
+    pos_start = pos_end + delim_len;
+    res.push_back(token);
+  }
+
+  res.push_back(s.substr(pos_start));
+  return res;
+}
+
+Map PLoadMapFromFile(std::string filepath) {
+  SDL_Log("Loading map from: %s", filepath.c_str());
+
+  Map map{};
+
+  std::ifstream mapFile(filepath);
+
+  std::string mapFileLine;
+
+  while (std::getline(mapFile, mapFileLine)) {
+    std::vector<std::string> mapCommand = split(mapFileLine, " ");
+
+    if (mapCommand[0] == "MAPNAME") {
+      map.mapName = mapCommand[1];
+    } else if (mapCommand[0] == "MAPVERS") {
+      map.mapVersion = mapCommand[1];
+    } else if (mapCommand[0] == "MAPAUTH") {
+      map.mapAuthor = mapCommand[1];
+    } else if (mapCommand[0] == "MAPSIZE") {
+      std::vector<std::string> mapSize = split(mapCommand[1], "x");
+      map.mapWidth = std::stoi(mapSize[0]);
+      map.mapHeight = std::stoi(mapSize[1]);
+    } else if (mapCommand[0] == "MAP") {
+    } else if (mapCommand[0] == "ENEMYS") {
+    } else if (mapCommand[0] == "TILE") {
+      map.data.mapTiles.push_back(mapCommand[1]);
+    } else if (mapCommand[0] == "ENEMY") {
+      map.data.mapEnemys.push_back(mapCommand[1]);
+    } else if (mapCommand[0] == "MAPSCAL") {
+      std::vector<std::string> mapScale = split(mapCommand[1], "x");
+      map.mapScaleX = std::stoi(mapScale[0]);
+      map.mapScaleY = std::stoi(mapScale[1]);
+    }
+  }
+
+  SDL_Log("Map info:");
+
+  SDL_Log("Map name: %s", map.mapName.c_str());
+  SDL_Log("Map author: %s", map.mapAuthor.c_str());
+  SDL_Log("Map version: %s", map.mapVersion.c_str());
+
+  SDL_Log("Map size: %ix%i", map.mapWidth, map.mapHeight);
+
+  SDL_Log("Map tile count: %s",
+          std::to_string(map.data.mapTiles.size()).c_str());
+
+  SDL_Log("Map enemy count: %s",
+          std::to_string(map.data.mapEnemys.size()).c_str());
+
+  return map;
+}
+
+void PRenderMap(Map *map) {
+
+  PhoenixTexture *brickWallTexture = PGetTextureById(BRICK_WALL_TEXTURE_ID);
+  PhoenixTexture *floorTexture = PGetTextureById(FLOOR_TEXTURE_ID);
+
+  int i = 0;
+  int row = 0;
+  for (auto tileName : map->data.mapTiles) {
+    if (i + 1 > map->mapWidth) {
+      row++;
+      i = 0;
+    }
+
+    int x = i * TEXTURE_WIDTH;
+    int y = row * TEXTURE_HEIGHT;
+
+    if (tileName == "WALL") {
+      PRenderTexture(brickWallTexture, x, y);
+    } else if (tileName == "FLOOR") {
+      PRenderTexture(floorTexture, x, y);
+    }
+
+    i++;
+  }
+}
+
+void PSaveMapToFile(Map *map, std::string filepath) {
+  std::string mapContent;
+  mapContent += "MAPNAME " + map->mapName + "\n";
+  mapContent += "MAPVERS " + map->mapVersion + "\n";
+  mapContent += "MAPAUTH " + map->mapAuthor + "\n";
+  mapContent += "MAPSIZE " + std::to_string(map->mapWidth) + "x" +
+                std::to_string(map->mapHeight) + "\n";
+
+  mapContent += "MAPSCAL " + std::to_string(map->mapScaleX) + "x" +
+                std::to_string(map->mapScaleY) + "\n";
+
+  mapContent += "MAP\n";
+  // Map data
+  for (auto tile : map->data.mapTiles) {
+    mapContent += "TILE " + tile + "\n";
+  }
+  mapContent += "ENDMAP\n";
+
+  SDL_Log("Saving map to: %s", filepath.c_str());
+
+  std::ofstream mapFile;
+  mapFile.open(filepath, std::ios::trunc);
+
+  mapFile << mapContent;
+  mapFile.close();
+}

src/mapEditor.cpp

@@ -0,0 +1,223 @@
+#include "mapEditor.hpp"
+#include "imgui.h"
+#include "imgui_impl_sdl2.h"
+#include "imgui_impl_sdlrenderer.h"
+#include "map.hpp"
+#include "mapEditorState.hpp"
+#include "misc/cpp/imgui_stdlib.h"
+#include "phoenix.hpp"
+#include "state.hpp"
+#include <SDL.h>
+#include <SDL_events.h>
+#include <SDL_keycode.h>
+#include <stdio.h>
+
+#if !SDL_VERSION_ATLEAST(2, 0, 17)
+#error This backend requires SDL 2.0.17+ because of SDL_RenderGeometry() function
+#endif
+
+// Main code
+void runMapEditor() {
+  // Setup SDL
+  if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_GAMECONTROLLER) !=
+      0) {
+    printf("Error: %s\n", SDL_GetError());
+    return;
+  }
+
+  // From 2.0.18: Enable native IME.
+#ifdef SDL_HINT_IME_SHOW_UI
+  SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1");
+#endif
+
+  // Create window with SDL_Renderer graphics context
+  SDL_WindowFlags window_flags =
+      (SDL_WindowFlags)(SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
+  SDL_Window *window = SDL_CreateWindow(
+      "Dear ImGui SDL2+SDL_Renderer example", SDL_WINDOWPOS_CENTERED,
+      SDL_WINDOWPOS_CENTERED, 1280, 720, window_flags);
+  state.renderer = SDL_CreateRenderer(
+      window, -1, SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_ACCELERATED);
+  if (state.renderer == nullptr) {
+    SDL_Log("Error creating SDL_Renderer!");
+    return;
+  }
+  // SDL_RendererInfo info;
+  // SDL_GetRendererInfo(renderer, &info);
+  // SDL_Log("Current SDL_Renderer: %s", info.name);
+
+  // Setup Dear ImGui context
+  IMGUI_CHECKVERSION();
+  ImGui::CreateContext();
+  ImGuiIO &io = ImGui::GetIO();
+  (void)io;
+  io.ConfigFlags |=
+      ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
+  io.ConfigFlags |=
+      ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
+
+  // Setup Dear ImGui style
+  // ImGui::StyleColorsDark();
+  ImGui::StyleColorsLight();
+
+  // Setup Platform/Renderer backends
+  ImGui_ImplSDL2_InitForSDLRenderer(window, state.renderer);
+  ImGui_ImplSDLRenderer_Init(state.renderer);
+
+  // Load Fonts
+  // - If no fonts are loaded, dear imgui will use the default font. You can
+  // also load multiple fonts and use ImGui::PushFont()/PopFont() to select
+  // them.
+  // - AddFontFromFileTTF() will return the ImFont* so you can store it if you
+  // need to select the font among multiple.
+  // - If the file cannot be loaded, the function will return a nullptr. Please
+  // handle those errors in your application (e.g. use an assertion, or display
+  // an error and quit).
+  // - The fonts will be rasterized at a given size (w/ oversampling) and stored
+  // into a texture when calling ImFontAtlas::Build()/GetTexDataAsXXXX(), which
+  // ImGui_ImplXXXX_NewFrame below will call.
+  // - Use '#define IMGUI_ENABLE_FREETYPE' in your imconfig file to use Freetype
+  // for higher quality font rendering.
+  // - Read 'docs/FONTS.md' for more instructions and details.
+  // - Remember that in C/C++ if you want to include a backslash \ in a string
+  // literal you need to write a double backslash \\ !
+  // io.Fonts->AddFontDefault();
+  // io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\segoeui.ttf", 18.0f);
+  // io.Fonts->AddFontFromFileTTF("../../misc/fonts/DroidSans.ttf", 16.0f);
+  // io.Fonts->AddFontFromFileTTF("../../misc/fonts/Roboto-Medium.ttf", 16.0f);
+  // io.Fonts->AddFontFromFileTTF("../../misc/fonts/Cousine-Regular.ttf", 15.0f);
+  // ImFont* font =
+  // io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f,
+  // nullptr, io.Fonts->GetGlyphRangesJapanese()); IM_ASSERT(font != nullptr);
+
+  // Our state
+  ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);
+  EditorGlobalState editorState{};
+
+  // Load textures
+  PRunBoostrap();
+
+  // Main loop
+  bool done = false;
+  while (!done) {
+    // Poll and handle events (inputs, window resize, etc.)
+    // You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to
+    // tell if dear imgui wants to use your inputs.
+    // - When io.WantCaptureMouse is true, do not dispatch mouse input data to
+    // your main application, or clear/overwrite your copy of the mouse data.
+    // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input
+    // data to your main application, or clear/overwrite your copy of the
+    // keyboard data. Generally you may always pass all inputs to dear imgui,
+    // and hide them from your application based on those two flags.
+    SDL_Event event;
+    while (SDL_PollEvent(&event)) {
+      ImGui_ImplSDL2_ProcessEvent(&event);
+
+      if (event.type == SDL_MOUSEBUTTONDOWN && !ImGui::IsAnyItemActive() &&
+          !ImGui::IsWindowFocused(ImGuiFocusedFlags_AnyWindow) &&
+          !ImGui::IsAnyItemHovered()) {
+        if (event.button.button == SDL_BUTTON_LEFT) {
+          if (editorState.placeTileMode) {
+            editorState.currentMap.data.mapTiles.push_back(
+                editorState.selectedTileName);
+          }
+        } else if (event.button.button == SDL_BUTTON_RIGHT) {
+          if (editorState.placeTileMode) {
+            editorState.currentMap.data.mapTiles.pop_back();
+          }
+        }
+      }
+      if (event.type == SDL_KEYDOWN) {
+        if (event.key.keysym.scancode == SDL_SCANCODE_PAGEDOWN) {
+          editorState.placeTileMode = !editorState.placeTileMode;
+          SDL_Log("Toggled place tile on click");
+        }
+      }
+
+      if (event.type == SDL_QUIT)
+        done = true;
+      if (event.type == SDL_WINDOWEVENT &&
+          event.window.event == SDL_WINDOWEVENT_CLOSE &&
+          event.window.windowID == SDL_GetWindowID(window))
+
+        done = true;
+    }
+
+    // Start the Dear ImGui frame
+    ImGui_ImplSDLRenderer_NewFrame();
+    ImGui_ImplSDL2_NewFrame();
+    ImGui::NewFrame();
+
+    ImGui::Begin("Phoenix Map Editor");
+
+    ImGui::Text("The Phoenix map editor outputs .map files which can be loaded "
+                "by phoenix");
+    ImGui::InputText("##Level file path", &editorState.mapFilePath);
+    ImGui::SameLine();
+    if (ImGui::Button("Load .map file")) {
+      editorState.currentMap = PLoadMapFromFile(editorState.mapFilePath);
+      editorState.loadedMap = true;
+    }
+    ImGui::End();
+
+    if (editorState.loadedMap) {
+      ImGui::Begin("Map Editor Tools");
+
+      ImGui::Text("Keybinds:");
+      ImGui::Text("PageDown : Toggle place tile on click");
+
+      if (ImGui::Button("Save level file")) {
+        PSaveMapToFile(&editorState.currentMap, editorState.mapFilePath);
+      }
+
+      const char *tileNames[] = {"WALL", "FLOOR"};
+
+      ImGui::Text("Selected tile");
+      ImGui::SameLine();
+      if (ImGui::BeginCombo("##EditorSelectedTile",
+                            editorState.selectedTileName)) {
+        for (int i = 0; i < IM_ARRAYSIZE(tileNames); i++) {
+          bool isSelected = (editorState.selectedTileName == tileNames[i]);
+          if (ImGui::Selectable(tileNames[i], isSelected)) {
+            editorState.selectedTileName = tileNames[i];
+            SDL_Log("Selected tile: %s", editorState.selectedTileName);
+          }
+
+          if (isSelected) {
+            ImGui::SetItemDefaultFocus();
+          }
+        }
+
+        ImGui::EndCombo();
+      }
+
+      ImGui::End();
+    }
+
+    // Rendering
+    ImGui::Render();
+    SDL_RenderSetScale(state.renderer, io.DisplayFramebufferScale.x,
+                       io.DisplayFramebufferScale.y);
+    SDL_SetRenderDrawColor(state.renderer, (Uint8)(clear_color.x * 255),
+                           (Uint8)(clear_color.y * 255),
+                           (Uint8)(clear_color.z * 255),
+                           (Uint8)(clear_color.w * 255));
+    SDL_RenderClear(state.renderer);
+    ImGui_ImplSDLRenderer_RenderDrawData(ImGui::GetDrawData());
+
+    if (editorState.loadedMap) {
+      PRenderMap(&editorState.currentMap);
+    }
+
+    SDL_RenderPresent(state.renderer);
+  }
+
+  // Cleanup
+  ImGui_ImplSDLRenderer_Shutdown();
+  ImGui_ImplSDL2_Shutdown();
+  ImGui::DestroyContext();
+
+  SDL_DestroyRenderer(state.renderer);
+  SDL_DestroyWindow(window);
+  SDL_Quit();
+}

src/mapEditor.hpp

@@ -0,0 +1,3 @@
+#pragma once
+
+void runMapEditor();

src/mapEditorState.hpp

@@ -0,0 +1,11 @@
+#pragma once
+#include "map.hpp"
+#include <string>
+
+struct EditorGlobalState {
+  std::string mapFilePath;
+  bool loadedMap = false;
+  bool placeTileMode = false;
+  Map currentMap;
+  const char *selectedTileName = "WALL";
+};

src/phoenix.cpp

@@ -0,0 +1,96 @@
+#include "assets.hpp"
+#include "texture.hpp"
+#include <SDL_image.h>
+#include <SDL_pixels.h>
+#include <SDL_render.h>
+#include <config.hpp>
+#include <iostream>
+#include <phoenix.hpp>
+#include <state.hpp>
+
+GlobalState state;
+
+void PRunBoostrap() {
+  PLoadTextureAsset("assets/textures/wall_brick.png");
+  PLoadTextureAsset("assets/textures/floor.png");
+}
+
+PhoenixGame::PhoenixGame() {
+
+  SDL_Init(SDL_INIT_VIDEO);
+  IMG_Init(IMG_INIT_PNG);
+
+  state.window = SDL_CreateWindow("Phoenix", SDL_WINDOWPOS_CENTERED,
+                                  SDL_WINDOWPOS_CENTERED, 1000, 1000, 0);
+
+  state.renderer = SDL_CreateRenderer(
+      state.window, -1, SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_ACCELERATED);
+
+  // Load textures
+  PRunBoostrap();
+
+  m_currentMap = PLoadMapFromFile("maps/dm_scale.map");
+  m_viewport = {0, 0, SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2};
+}
+
+void PhoenixGame::present() {
+  SDL_RenderSetViewport(state.renderer, &m_viewport);
+  SDL_RenderPresent(state.renderer);
+}
+
+void PhoenixGame::render() {
+
+  SDL_RenderSetScale(state.renderer, m_currentMap.mapScaleX,
+                     m_currentMap.mapScaleY);
+  SDL_SetRenderDrawColor(state.renderer, 0, 0, 0, 255);
+  SDL_RenderClear(state.renderer);
+
+  PRenderMap(&m_currentMap);
+
+  //  PRenderTexture(&m_texture, 0, 0);
+}
+
+void PhoenixGame::run() {
+  mb_isOpen = true;
+
+  while (mb_isOpen) {
+    SDL_Event event;
+
+    while (SDL_PollEvent(&event)) {
+      if (event.type == SDL_QUIT) {
+        mb_isOpen = false;
+        break;
+      }
+    }
+
+    unsigned char const *keys = SDL_GetKeyboardState(nullptr);
+    if (keys[SDL_SCANCODE_UP]) {
+      m_viewport.w += 5;
+      m_viewport.h += 5;
+    } else if (keys[SDL_SCANCODE_DOWN]) {
+      m_viewport.w -= 5;
+      m_viewport.h -= 5;
+    } else if (keys[SDL_SCANCODE_W]) {
+      m_viewport.y += 20;
+      if (m_viewport.y > 0)
+        m_viewport.y = 0;
+    } else if (keys[SDL_SCANCODE_S]) {
+      m_viewport.y -= 20;
+      if (m_viewport.y < -720)
+        m_viewport.y = -720;
+    } else if (keys[SDL_SCANCODE_A]) {
+      m_viewport.x += 20;
+    } else if (keys[SDL_SCANCODE_D]) {
+      m_viewport.x -= 20;
+      if (m_viewport.x < -1280)
+        m_viewport.x = -1280;
+    }
+
+    // Rendering code
+
+    render();
+    present();
+
+    // End rendering code
+  }
+}

src/texture.cpp

@@ -0,0 +1,34 @@
+#include "config.hpp"
+#include <SDL.h>
+#include <SDL_image.h>
+#include <SDL_log.h>
+#include <state.hpp>
+#include <texture.hpp>
+
+PhoenixTexture PLoadTexture(std::string filePath) {
+  SDL_Log("Loading texture from path: %s", filePath.c_str());
+
+  PhoenixTexture texture{};
+  texture.texture = IMG_LoadTexture(state.renderer, filePath.c_str());
+
+  if (texture.texture == NULL) {
+    SDL_Log("Failed to load image: %s", SDL_GetError());
+    abort();
+  }
+
+  return texture;
+}
+
+void PDestroyTexture(PhoenixTexture *texture) {
+  SDL_DestroyTexture(texture->texture);
+}
+
+void PRenderTexture(PhoenixTexture *texture, int x, int y) {
+  SDL_Rect dstRect{};
+  dstRect.x = x;
+  dstRect.y = y;
+  dstRect.w = TEXTURE_WIDTH;
+  dstRect.h = TEXTURE_HEIGHT;
+
+  SDL_RenderCopy(state.renderer, texture->texture, NULL, &dstRect);
+}