MVP

.gitignore

@@ -0,0 +1,2 @@
+.vscode
+build

CMakeLists.txt

@@ -0,0 +1,44 @@
+cmake_minimum_required(VERSION 3.0.0)
+project(Tactics VERSION 1.0.1)
+
+find_package(SFML 2.5 COMPONENTS window graphics REQUIRED)
+find_package(Qt5 COMPONENTS Widgets REQUIRED)
+find_package(nlohmann_json 3.2.0 REQUIRED)
+
+set(QT_HEADER_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include/qt)
+qt5_wrap_cpp(Tactics_H ${QT_HEADER_DIR}/chooseopponentform.h ${QT_HEADER_DIR}/entranceform.h ${QT_HEADER_DIR}/gameform.h ${QT_HEADER_DIR}/mainwindow.h)
+
+set(QT_UI_DIR ${CMAKE_CURRENT_SOURCE_DIR}/ui)
+set(QT_UI_COMPILED ${CMAKE_CURRENT_BINARY_DIR}/ui)
+execute_process(COMMAND mkdir ${QT_UI_COMPILED})
+
+list(APPEND QT_WINDOWS "entranceform" "chooseopponentform" "gameform" "mainwindow")
+
+foreach(QT_UI IN LISTS QT_WINDOWS)
+    set(QT_UI_OUT_FILE "${QT_UI_COMPILED}/ui_${QT_UI}.h")
+    set(QT_UIS_FULL_NAME_WITH_EXT "${QT_UI_DIR}/${QT_UI}.ui")
+    execute_process(COMMAND uic -o ${QT_UI_OUT_FILE} ${QT_UIS_FULL_NAME_WITH_EXT})
+endforeach()
+
+file(GLOB GRAPHICS_SRC "src/graphics/*.cpp")
+file(GLOB GRAPHICS_H "include/graphics/*.hpp")
+add_library(graphics ${GRAPHICS_SRC} ${GRAPHICS_H})
+target_link_libraries(graphics nlohmann_json::nlohmann_json)
+target_link_libraries(graphics sfml-window sfml-graphics)
+target_include_directories(graphics PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+file(GLOB MODEL "src/model/*.cpp")
+file(GLOB INPUT "src/input/*.cpp")
+file(GLOB SERVER "src/server/*.cpp")
+file(GLOB QT "src/qt/*.cpp")
+set(Tactics_SRC main.cpp ${QT} ${MODEL} ${INPUT} #${SERVER} 
+)
+
+add_executable(tactics ${Tactics_SRC} ${Tactics_H})
+
+target_include_directories(tactics PUBLIC include/qt)
+target_include_directories(tactics PUBLIC ${QT_UI_COMPILED})
+target_link_libraries(tactics Qt5::Widgets)
+target_link_libraries(tactics graphics)
+
+include_directories(include)

config.json

@@ -0,0 +1,15 @@
+{
+    "static_dir" : "../static/",
+    "units": "unit.png",
+    "map": "map.png",
+    "font": "arkhip.ttf",
+    "animation_time": 0.1,
+    "info_bar":      [ 24, 47, 74, 90],
+    "basic_cell":      [ 26, 219],
+    "border_cell":     [ 26, 298],
+    "broken_cell":     [ 106, 219],
+    "my_warrior":      [ 1, 1],
+    "enemy_warrior":   [ 1, 65],
+    "my_king":         [ 193, 1],
+    "enemy_king":      [ 193, 65]
+}

include/graphics/graphics.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <SFML/Graphics.hpp>
+#include <memory>
+#include <vector>
+
+using std::vector;
+
+class IModel;
+class IFieldModel;
+
+enum class ModelType { Warrior, King, Trees, Camp };
+
+class IObjectModel;
+class Stats;
+
+class IMonitor {
+   public:
+    virtual ~IMonitor() {}
+
+    virtual void Prepare() = 0;
+    virtual void Draw() = 0;
+    virtual bool IsEnd() = 0;
+    virtual std::unique_ptr<IObjectModel> GetModel(ModelType type, bool is_mine) = 0;
+    virtual std::unique_ptr<IFieldModel> GetFieldModel(
+        const std::vector<std::string> &map) = 0;
+};
+
+class IModel {
+   public:
+    virtual ~IModel() {}
+
+    virtual void Draw() = 0;
+};
+
+class IFieldModel : public IModel {
+   public:
+    virtual ~IFieldModel() {}
+
+    virtual void SetCurrent(sf::Vector2u pos) = 0;
+    virtual void ResetCurrent() = 0;
+    virtual void SetStat(Stats stat) = 0;
+    virtual void ShowStat() = 0;
+    virtual void HideStat() = 0;
+};
+
+class IObjectModel : public IModel {
+   public:
+    virtual ~IObjectModel() {}
+
+    virtual void Move(sf::Vector2u pos) = 0;
+    virtual void Attack(sf::Vector2u pos) = 0;
+    virtual void GetDamage(int damage, sf::Vector2u pos_) = 0;
+    virtual void Blow() = 0;
+};

include/graphics/sfml_monitor.hpp

@@ -0,0 +1,185 @@
+#pragma once
+
+#include <SFML/Graphics.hpp>
+#include <SFML/Window.hpp>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+#include "graphics/graphics.hpp"
+#include "utility/common.h"
+
+using sf::Vector2u;
+using std::string;
+
+enum class Animation {
+    Hit,
+    Hurt,
+    Run,
+    None,
+    Blow,
+    Open,
+};
+
+struct Stats {
+    int hp, armor, attack;
+};
+
+class SFMLModel : public IModel {
+   protected:
+    sf::Sprite sprite;
+    Animation anim;
+    double anim_frame_;
+
+    sf::RenderWindow &target_;
+
+   public:
+    virtual ~SFMLModel() {}
+
+    SFMLModel(sf::RenderWindow &target) : target_(target) {}
+    void SetOrigin(float x, float y) { sprite.setOrigin(x, y); }
+    void SetTextRect(const sf::IntRect& rect) { sprite.setTextureRect(rect); }
+    void Scale(float x, float y) { sprite.scale(x,y); }
+};
+
+class InfoBar : SFMLModel {
+   private:
+    sf::Text text;
+
+   public:
+    InfoBar(sf::RenderWindow &window, const sf::Font &font,
+            const sf::Texture &texture, sf::IntRect tRect);
+
+    void Draw() override;
+    void UpdateInfo(Stats stats);
+    void setPos(sf::Vector2f pos) {
+        sprite.setPosition(pos);
+        text.setPosition(pos.x + 20, pos.y + 50);
+    }
+    void open() {
+        anim_frame_ = 0;
+        anim = Animation::Open;
+    }
+    void close() { anim_frame_ = 0; }
+};
+
+class SFMLFieldModel : public IFieldModel, public SFMLModel {
+   private:
+    std::vector<string> tile_map_;
+    sf::Vector2u size_;
+    sf::Vector2u current_;
+    InfoBar ibar;
+    int is_info;
+
+   public:
+    SFMLFieldModel(sf::RenderWindow &window, const sf::Texture &texture,
+                   const sf::Font &font, const std::vector<std::string> &map);
+
+    void Draw() override;
+
+    void SetCurrent(sf::Vector2u pos) override { current_ = pos; };
+    void ResetCurrent() override {
+        current_.x = -1;
+        current_.y = -1;
+    }
+    void SetStat(Stats stat);
+    void ShowStat() {
+        if (is_info) ibar.Draw();
+    };
+    void HideStat() {
+        is_info = false;
+        ibar.close();
+    };
+};
+
+
+class SFMLUnitModel : public SFMLModel, public IObjectModel {
+   protected:
+    sf::Vector2i mov_vec;
+    sf::Vector2u pos;
+    double mov_anim_speed;
+    bool is_mine_;
+    bool right;
+
+    void setRight() {
+        if (right) return;
+        sprite.scale(-1, 1);
+        sprite.setOrigin(0, 0);
+        right = true;
+    }
+    void setLeft() {
+        if (!right) return;
+        sprite.scale(-1, 1);
+        sprite.setOrigin(CELL_TEXTURE_SIZE, 0);
+        right = false;
+    }
+
+   public:
+    SFMLUnitModel(sf::RenderWindow &window, const sf::Texture &texture,
+                  bool is_mine);
+
+    virtual void Draw() = 0;
+    void Move(sf::Vector2u to) override;
+    void Attack(sf::Vector2u pos_) override;
+    void GetDamage(int damage, sf::Vector2u pos_) override;
+    void Blow() { anim = Animation::Blow; };
+};
+
+class SFMLWarriorModel : public SFMLUnitModel {
+   public:
+    SFMLWarriorModel(sf::RenderWindow &window, const sf::Texture &texture,
+                     bool is_mine);
+
+    void Draw() override;
+};
+
+class SFMLKingModel : public SFMLUnitModel {
+   public:
+    SFMLKingModel(sf::RenderWindow &window, const sf::Texture &texture,
+                  bool is_mine);
+
+    void Draw() override;
+};
+
+
+class SFMLEnvModel : public SFMLModel, public IObjectModel {
+   public:
+    SFMLEnvModel(sf::RenderWindow &window, const sf::Texture &texture);
+
+    void Move(sf::Vector2u pos) override {
+        sprite.setPosition(pos.x * CELL_SIZE, pos.y * CELL_SIZE);
+    }
+    void Draw() override { target_.draw(sprite); };
+    void Attack(sf::Vector2u pos_) override {};
+    void GetDamage(int damage, sf::Vector2u pos) override{};
+    void Blow() override {};
+};
+
+class SFMLWindow : public IMonitor {
+   private:
+    sf::RenderWindow m_window_;
+    sf::Vector2u m_windowSize_;
+    std::string m_windowTitle_;
+    sf::Texture tile_set_;
+    sf::Texture units_set_;
+    sf::Font font_;
+
+    void Destroy() { m_window_.close(); }
+
+   public:
+    SFMLWindow(const string &l_title, const sf::Vector2u &l_size,
+               sf::WindowHandle win_descriptor, const std::string& config_path);
+    bool loadResources(const std::string& config_path);
+
+    void Prepare() { m_window_.clear(); }
+    void Draw() { m_window_.display(); }
+    bool IsEnd() { return !m_window_.isOpen(); }
+
+    sf::Vector2u GetWindowSize() { return m_windowSize_; }
+    std::unique_ptr<IObjectModel> GetModel(ModelType type, bool is_mine);
+    std::unique_ptr<IFieldModel> GetFieldModel(
+        const std::vector<std::string> &map);
+    sf::RenderWindow &GetWindow() { return m_window_; }
+
+    ~SFMLWindow() { Destroy(); }
+};

include/input/input_handler.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <unordered_map>
+#include <SFML/Graphics.hpp>
+#include "utility/common.h"
+
+enum EventType { CHOSE, UNCHOSE, CREATE_OBJECT, MOVE_CMD, ATTACK_CMD, FINISH, INFO };
+
+struct GameEvent
+{
+    EventType type;
+
+    union
+    {
+        sf::Vector2u cords;
+        UnitType unit_type;
+        char* cmds;
+    };
+};
+
+struct InputHandler {
+    virtual GameEvent Handle() = 0;
+};

include/input/sfml_input.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <SFML/Window.hpp>
+
+#include "input/input_handler.hpp"
+
+class SFMLWindowHandler : public InputHandler {
+   private:
+    sf::Window &window;
+
+   public:
+    SFMLWindowHandler(sf::Window &window) : window(window) {}
+
+    GameEvent Handle();
+
+    ~SFMLWindowHandler() {}
+};