建档

source_game/Actor/Map/GameMap.cpp

@@ -0,0 +1,369 @@
+#include "GameMap.h"
+#include "Asset/AssetManager.h"
+#include "EngineFrame/Scene/Scene.h"
+#include "EngineFrame/Component/Animation.h"
+#include "Actor/Map/GameMapCamera.h"
+#include "Actor/Object/CharacterObject.h"
+
+GameMap::GameMap()
+{
+    _LayerMap["contact"] = new GameMapLayer();
+    _LayerMap["distantback"] = new GameMapLayer();
+    _LayerMap["middleback"] = new GameMapLayer();
+    _LayerMap["bottom"] = new GameMapLayer();
+    _LayerMap["closeback"] = new GameMapLayer();
+    _LayerMap["normal"] = new GameMapLayer();
+    _LayerMap["close"] = new GameMapLayer();
+    _LayerMap["cover"] = new GameMapLayer();
+    _LayerMap["max"] = new GameMapLayer();
+
+    // 设置图层渲染顺序
+    _LayerMap["contact"]->SetRenderZOrder(10000);
+    _LayerMap["distantback"]->SetRenderZOrder(50000);
+    _LayerMap["middleback"]->SetRenderZOrder(100000);
+    _LayerMap["bottom"]->SetRenderZOrder(150000);
+    _LayerMap["closeback"]->SetRenderZOrder(200000);
+    _LayerMap["normal"]->SetRenderZOrder(250000);
+    _LayerMap["close"]->SetRenderZOrder(300000);
+    _LayerMap["cover"]->SetRenderZOrder(350000);
+    _LayerMap["max"]->SetRenderZOrder(400000);
+}
+
+GameMap::~GameMap()
+{
+}
+
+void GameMap::InitConfiguration(std::string mapName)
+{
+    ScriptData Data = AssetManager::GetInstance().GetScriptInfo(mapName);
+    _MapInfo["wide_mode_camer_vertical_correction"] = 0;
+    _MapInfo["background_pos"] = 0;
+    _MapPath = mapName;
+    _MapDir = mapName.substr(0, mapName.find_last_of("/") + 1);
+    while (!Data.IsEnd())
+    {
+        std::string Segment = Data.Get();
+        if (Segment == "[background pos]")
+        {
+            _MapInfo["background_pos"] = std::stoi(Data.Get());
+        }
+        else if (Segment == "[map name]")
+        {
+            _MapInfo["name"] = Data.Get();
+        }
+        else if (Segment == "[wide mode camera vertical correction]")
+        {
+            _MapInfo["wide_mode_camer_vertical_correction"] = std::stoi(Data.Get());
+        }
+        else if (Segment == "[tile]")
+        {
+            std::vector<std::string> tileArry;
+            while (true)
+            {
+                auto tiledata = Data.Get();
+                if (tiledata == "[/tile]")
+                    break;
+                tileArry.push_back(_MapDir + Tool_toLowerCase(tiledata));
+            }
+            _MapInfo["tile"] = tileArry;
+        }
+        else if (Segment == "[extended tile]")
+        {
+            std::vector<std::string> tileArry;
+            while (true)
+            {
+                auto tiledata = Data.Get();
+                if (tiledata == "[/extended tile]")
+                    break;
+                tileArry.push_back(_MapDir + Tool_toLowerCase(tiledata));
+            }
+            _MapInfo["extended_tile"] = tileArry;
+        }
+        else if (Segment == "[far sight scroll]" || Segment == "[middle sight scroll]" || Segment == "[near sight scroll]")
+        {
+            _MapInfo[Segment.substr(1, Segment.length() - 2)] = std::stoi(Data.Get());
+        }
+        else if (Segment == "[background animation]")
+        {
+            std::vector<BackGroundAni> Arr;
+            while (true)
+            {
+                std::string aniData = Data.Get();
+                if (aniData == "[/background animation]")
+                    break;
+                if (aniData == "[ani info]")
+                {
+                    BackGroundAni ani;
+                    Data.Get();
+                    ani.filename = _MapDir + Tool_toLowerCase(Data.Get());
+                    Data.Get();
+                    ani.layer = Data.Get();
+                    Data.Get();
+                    ani.order = Data.Get();
+                    Arr.push_back(ani);
+                }
+            }
+            _MapInfo["background_animation"] = Arr;
+        }
+        else if (Segment == "[sound]")
+        {
+            std::vector<std::string> soundArry;
+            while (true)
+            {
+                std::string sounddata = Data.Get();
+                if (sounddata == "[/sound]")
+                    break;
+                soundArry.push_back(sounddata);
+            }
+            _MapInfo["sound"] = soundArry;
+        }
+        else if (Segment == "[animation]")
+        {
+            std::vector<MapAni> aniArry;
+            while (true)
+            {
+                std::string aniData = Data.Get();
+                if (aniData == "[/animation]")
+                    break;
+                MapAni info;
+                info.filename = Tool_RegRealPath(_MapDir + Tool_toLowerCase(aniData));
+                info.layer = Data.Get();
+                info.XPos = std::stoi(Data.Get());
+                info.YPos = std::stoi(Data.Get());
+                info.ZPos = std::stoi(Data.Get());
+                aniArry.push_back(info);
+            }
+            _MapInfo["animation"] = aniArry;
+        }
+        else if (Segment == "[NPC]")
+        {
+            std::vector<MapNpc> npcArry;
+            while (true)
+            {
+                std::string npcData = Data.Get();
+                if (npcData == "[/NPC]")
+                    break;
+                MapNpc info;
+                info.id = std::stoi(npcData);
+                info.direction = Data.Get();
+                info.XPos = std::stoi(Data.Get());
+                info.YPos = std::stoi(Data.Get());
+                info.ZPos = std::stoi(Data.Get());
+                npcArry.push_back(info);
+            }
+            _MapInfo["NPC"] = npcArry;
+        }
+        else if (Segment == "[town movable area]")
+        {
+            std::vector<int> town_movable_area;
+            std::vector<MapMoveArea> town_movable_area_info;
+            while (true)
+            {
+                std::string areadata = Data.Get();
+                if (areadata == "[/town movable area]")
+                    break;
+                town_movable_area.push_back(std::stoi(areadata));
+                town_movable_area.push_back(std::stoi(areadata));
+                town_movable_area.push_back(std::stoi(areadata));
+                town_movable_area.push_back(std::stoi(areadata));
+                MapMoveArea T;
+                T.town = std::stoi(areadata);
+                T.area = std::stoi(areadata);
+                town_movable_area_info.push_back(T);
+            }
+            _MapInfo["town_movable_area"] = town_movable_area;
+            _MapInfo["town_movable_area_info"] = town_movable_area_info;
+        }
+        else if (Segment == "[virtual movable area]")
+        {
+            std::vector<int> virtual_movable_area;
+            while (true)
+            {
+                std::string areadata = Data.Get();
+                if (areadata == "[/virtual movable area]")
+                    break;
+                virtual_movable_area.push_back(std::stoi(areadata));
+                virtual_movable_area.push_back(std::stoi(Data.Get()));
+                virtual_movable_area.push_back(std::stoi(Data.Get()));
+                virtual_movable_area.push_back(std::stoi(Data.Get()));
+            }
+            _MapInfo["virtual_movable_area"] = virtual_movable_area;
+        }
+    }
+}
+
+void GameMap::InitTile()
+{
+    if (!_MapInfo.count("tile"))
+        return;
+    int NormalTileCount = 0;
+    std::vector<std::string> tileArr = std::get<std::vector<std::string>>(_MapInfo["tile"]);
+    if (tileArr.size() > 0)
+    {
+        NormalTileCount = tileArr.size();
+        _MapLength = NormalTileCount * 224;
+        for (int i = 0; i < NormalTileCount; i++)
+        {
+            std::string path = tileArr[i];
+            RefPtr<Tile> tile = new Tile(path);
+            tile->SetPos(VecFPos{i * 224, -200 - std::get<int>(_MapInfo["background_pos"])});
+            _LayerMap["bottom"]->AddComponent(tile);
+        }
+        _MapHeight = 560;
+    }
+    if (_MapInfo.count("extended_tile"))
+    {
+        std::vector<std::string> extileArr = std::get<std::vector<std::string>>(_MapInfo["extended_tile"]);
+        if (extileArr.size() > 0)
+        {
+            int ExTileCount = extileArr.size();
+            int Buffer = (ExTileCount / NormalTileCount);
+            _MapHeight += (Buffer < 1 ? 1 : Buffer) * 40;
+            for (int i = 0; i < ExTileCount; i++)
+            {
+                std::string path = extileArr[i];
+                RefPtr<Tile> tile = new Tile(path);
+                int xbuf = i % NormalTileCount * 224;
+                int ybuf = 560 - 200 - std::get<int>(_MapInfo["background_pos"]) + 40 * (i / NormalTileCount);
+                tile->SetPos(VecFPos{xbuf, ybuf});
+                _LayerMap["bottom"]->AddComponent(tile);
+            }
+        }
+    }
+}
+
+void GameMap::InitBackgroundAnimation()
+{
+    float Rate = _MapInfo.count("far_sight_scroll") ? std::get<int>(_MapInfo["far_sight_scroll"]) / 100.0f : 1.0f;
+    (void)Rate;
+    // TODO 摄像机
+    if (_MapInfo.count("background_animation"))
+    {
+        std::vector<BackGroundAni> aniArr = std::get<std::vector<BackGroundAni>>(_MapInfo["background_animation"]);
+        for (auto &ani : aniArr)
+        {
+            std::string path = ani.filename;
+            std::vector<RefPtr<Animation>> AniList;
+            RefPtr<Animation> AniObj = new Animation(path);
+            int width = AniObj->GetSize().width;
+            AniList.push_back(AniObj);
+            for (int i = 0; i < (_MapLength * Rate) / width; i++)
+            {
+                RefPtr<Animation> AniObj = new Animation(path);
+                AniList.push_back(AniObj);
+            }
+            for (int i = 0; i < (int)AniList.size(); i++)
+            {
+                AniList[i]->SetPos(VecFPos{i * width, -120});
+                AniList[i]->SetRenderZOrder(-1000000);
+                std::string layer = ani.layer;
+                layer = layer.substr(1, layer.length() - 2);
+                if (_LayerMap.count(layer))
+                {
+                    _LayerMap[layer]->AddChild(AniList[i]);
+                }
+                else
+                {
+                }
+            }
+        }
+    }
+}
+
+void GameMap::InitMapAnimation()
+{
+    if (_MapInfo.count("animation"))
+    {
+        std::vector<MapAni> aniArr = std::get<std::vector<MapAni>>(_MapInfo["animation"]);
+        for (auto &ani : aniArr)
+        {
+            std::string path = ani.filename;
+            RefPtr<Animation> AniObj = new Animation(path);
+            AniObj->SetPos(VecFPos{ani.XPos, ani.YPos - ani.ZPos});
+            AniObj->SetRenderZOrder(ani.YPos);
+            std::string layer = ani.layer;
+            layer = layer.substr(1, layer.length() - 2);
+            if (_LayerMap.count(layer))
+            {
+                _LayerMap[layer]->AddChild(AniObj);
+            }
+        }
+    }
+}
+
+void GameMap::LoadMap(std::string mapName)
+{
+    // 读取脚本配置
+    InitConfiguration(mapName);
+    // 初始化地板
+    InitTile();
+    // 初始化背景动画
+    InitBackgroundAnimation();
+    // 初始化场景Ani
+    InitMapAnimation();
+
+    RefPtr<CharacterObject> obj = new CharacterObject();
+    obj->SetPosition({620, 200, 0});
+    obj->Construction(0);
+    _LayerMap["normal"]->AddObject(obj);
+}
+
+void GameMap::Enter(Scene *scene)
+{
+    scene->AddChild(_LayerMap["contact"]);
+    scene->AddChild(_LayerMap["distantback"]);
+    scene->AddChild(_LayerMap["middleback"]);
+    scene->AddChild(_LayerMap["bottom"]);
+    scene->AddChild(_LayerMap["closeback"]);
+    scene->AddChild(_LayerMap["normal"]);
+    scene->AddChild(_LayerMap["close"]);
+    scene->AddChild(_LayerMap["cover"]);
+    scene->AddChild(_LayerMap["max"]);
+
+    // TODO
+    int HSU = 230;
+    _LayerMap["contact"]->SetPos(VecFPos{0, HSU});
+    _LayerMap["distantback"]->SetPos(VecFPos{0, HSU});
+    _LayerMap["middleback"]->SetPos(VecFPos{0, HSU});
+    _LayerMap["bottom"]->SetPos(VecFPos{0, HSU});
+    _LayerMap["closeback"]->SetPos(VecFPos{0, HSU});
+    _LayerMap["normal"]->SetPos(VecFPos{0, HSU});
+    _LayerMap["close"]->SetPos(VecFPos{0, HSU});
+    _LayerMap["cover"]->SetPos(VecFPos{0, HSU});
+    _LayerMap["max"]->SetPos(VecFPos{0, HSU});
+}
+
+void GameMap::HandleEvents(SDL_Event *e)
+{
+}
+
+void GameMap::Update(float deltaTime)
+{
+    // this->_Camera->Update(deltaTime);
+
+    // if (this->_Camera)
+    // {
+    //     int CamearXpos = this->_Camera->X;
+    //     int CamearYpos = this->_Camera->Y;
+    //     int CamearZpos = this->_Camera->Z;
+
+    //     SDL_Log("Camera Pos: %d, %d", CamearXpos, CamearYpos);
+    //     // 遍历
+    //     for (auto &pair : _LayerMap)
+    //     {
+    //         // pair.first 是 key（std::string）
+    //         std::string key = pair.first;
+    //         // pair.second 是 value（RefPtr<GameMapLayer>）
+    //         RefPtr<GameMapLayer> &value = pair.second;
+
+    //         if (key == "distantback")
+    //         {
+    //             value->SetPos(VecPos{(-CamearXpos + 553), (-CamearYpos + CamearZpos + 300 + 120 + 80)});
+    //         }
+    //         else
+    //         {
+    //             value->SetPos(VecPos{(-CamearXpos + 553), (-CamearYpos + CamearZpos + 300 + 120 + 80)});
+    //         }
+    //     }
+    // }
+}

source_game/Actor/Map/GameMap.h

@@ -0,0 +1,87 @@
+#pragma once
+#include "Actor/Map/GameMapLayer.h"
+#include "Asset/Asset_Script.h"
+#include "Actor/Map/Tile.h"
+#include <unordered_map>
+#include <vector>
+#include <variant>
+
+class BaseObject;
+class GameMapCamera;
+class GameMap
+{
+    struct BackGroundAni
+    {
+        std::string filename;
+        std::string layer;
+        std::string order;
+    };
+
+    struct MapAni
+    {
+        std::string filename;
+        std::string layer;
+        int XPos;
+        int YPos;
+        int ZPos;
+    };
+
+    struct MapNpc
+    {
+        int id;
+        std::string direction;
+        int XPos;
+        int YPos;
+        int ZPos;
+    };
+
+    struct MapMoveArea
+    {
+        int town;
+        int area;
+    };
+
+    using MapInfoBody = std::variant<
+        int,
+        std::string,
+        std::vector<BackGroundAni>,
+        std::vector<MapAni>,
+        std::vector<MapNpc>,
+        std::vector<MapMoveArea>,
+        std::vector<int>,
+        std::vector<std::string>>;
+
+public:
+    // 地图信息
+    std::unordered_map<std::string, MapInfoBody> _MapInfo;
+    // 地图路径
+    std::string _MapPath;
+    // 地图文件夹
+    std::string _MapDir;
+    // 地图宽度
+    int _MapLength = 0;
+    // 地图高度
+    int _MapHeight = 0;
+
+public:
+    // 图层Map   图层类型  显示对象
+    std::unordered_map<std::string, RefPtr<GameMapLayer>> _LayerMap;
+    // 摄像机对象
+    GameMapCamera *_Camera;
+
+
+public:
+    GameMap(/* args */);
+    ~GameMap();
+
+    void LoadMap(std::string mapName);
+    void InitConfiguration(std::string mapName);
+    void InitTile();
+    void InitBackgroundAnimation();
+    void InitMapAnimation();
+    void Enter(Scene *scene);
+    void HandleEvents(SDL_Event *e);
+    void Update(float deltaTime);
+
+public:
+};

source_game/Actor/Map/GameMapCamera.cpp

@@ -0,0 +1,54 @@
+#include "GameMapCamera.h"
+#include "Actor/Map/GameMap.h"
+#include "Actor/Object/BaseObject.h"
+#include <algorithm>
+
+GameMapCamera::GameMapCamera()
+{
+}
+
+GameMapCamera::~GameMapCamera()
+{
+}
+
+void GameMapCamera::SetParentMap(GameMap *map)
+{
+    this->_ParentMap = map;
+    _ParentMap->_Camera = this;
+}
+
+void GameMapCamera::SetFromActor(BaseObject *actor)
+{
+    this->_FromActor = actor;
+}
+
+void GameMapCamera::Update(float deltaTime)
+{
+    SyncPosByFromParent(deltaTime);
+}
+
+void GameMapCamera::SetPos(int x, int y, int z)
+{
+    this->X = x;
+    this->Y = y;
+    this->Z = z;
+}
+
+void GameMapCamera::AddPos(int x, int y, int z)
+{
+    this->X += x;
+    this->Y += y;
+    this->Z += z;
+}
+
+void GameMapCamera::SyncPosByFromParent(float deltaTime)
+{
+    if (this->_FromActor != nullptr)
+    {
+        // int R_X, R_Y, R_Z;
+        // R_X = std::min(std::max(this->_FromActor->X, 533), MovableAreaX - 533);
+        // R_Y = std::min(std::max(this->_FromActor->Y, 300), MovableAreaY - 300);
+        // R_Z = 0;
+        // SetPos(R_X, R_Y, R_Z);
+    }
+}

source_game/Actor/Map/GameMapCamera.h

@@ -0,0 +1,45 @@
+#pragma once
+#include "EngineFrame/Actor/Actor.h"
+class GameMap;
+class BaseObject;
+class GameMapCamera : public Actor
+{
+private:
+    GameMap *_ParentMap = nullptr;
+    // 跟随对象
+    BaseObject *_FromActor = nullptr;
+
+public:
+    // 摄像机坐标
+    int X = 0;
+    int Y = 0;
+    int Z = 0;
+    // 镜头可行坐标
+    int MovableAreaX = 0;
+    int MovableAreaY = 0;
+    // 背景偏移量
+    int BackgroundOffset = 0;
+    // 背景层移动速率
+    int BackgroundMoveSpeed = 1.0;
+    // 人物中线长度
+    int CharacterLineLength = 0;
+    // 摄像机朝向
+    int Direction = 1;
+    // 摄像机朝向时间
+    float DirectionTime = 0.f;
+    // 缩放比率
+    float CameraRate = 1.0;
+
+public:
+    GameMapCamera();
+    ~GameMapCamera();
+
+    void SetParentMap(GameMap *map);
+    void SetFromActor(BaseObject *actor);
+    void Update(float deltaTime);
+
+    void SetPos(int x, int y, int z);
+    void AddPos(int x, int y, int z);
+
+    void SyncPosByFromParent(float deltaTime);
+};

source_game/Actor/Map/GameMapLayer.cpp

@@ -0,0 +1,14 @@
+#include "GameMapLayer.h"
+
+GameMapLayer::GameMapLayer()
+{
+}
+
+GameMapLayer::~GameMapLayer()
+{
+}
+
+void GameMapLayer::AddObject(RefPtr<Actor> obj)
+{
+    this->AddChild(obj);
+}

source_game/Actor/Map/GameMapLayer.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "EngineFrame/Actor/Actor.h"
+#include "EngineFrame/Component/Sprite.h"
+
+class BaseObject;
+class GameMapLayer : public Actor
+{
+private:
+    //  地图对象
+    std::vector<RefPtr<Component>> ObjectManager;
+
+public:
+    GameMapLayer(/* args */);
+    ~GameMapLayer();
+
+public:
+    void AddObject(RefPtr<Actor> obj); // 添加对象
+};

source_game/Actor/Map/Tile.cpp

@@ -0,0 +1,45 @@
+#include "Tile.h"
+#include "Tool/Tool_String.h"
+Tile::Tile()
+{
+}
+
+Tile::Tile(std::string Path) : Sprite()
+{
+    InitInfo(Path);
+    if (std::get<std::string>(m_data["path"]) == "")
+        m_data["path"] = "sprite/character/common/circlecooltime.img";
+
+    m_texture = new Texture(std::get<std::string>(m_data["path"]), std::get<int>(m_data["idx"]));
+    Sprite::Init();
+}
+
+Tile::~Tile()
+{
+}
+
+void Tile::SetPos(VecFPos pos)
+{
+    pos.y += std::get<int>(m_data["pos"]);
+    Sprite::SetPos(pos);
+}
+
+void Tile::InitInfo(std::string Path)
+{
+    ScriptData Data = AssetManager::GetInstance().GetScriptInfo(Path);
+    m_data["pos"] = 0;
+    while (!Data.IsEnd())
+    {
+        std::string Segment = Data.Get();
+        if (Segment == "[IMAGE]")
+        {
+            std::string PathBuf = Tool_toLowerCase(Data.Get());
+            m_data["path"] = "sprite/" + PathBuf;
+            m_data["idx"] = std::stoi(Data.Get());
+        }
+        else if (Segment == "[img pos]")
+        {
+            m_data["pos"] = std::stoi(Data.Get());
+        }
+    }
+}

source_game/Actor/Map/Tile.h

@@ -0,0 +1,22 @@
+#pragma once
+#include "Asset/AssetManager.h"
+#include "EngineFrame/Component/Sprite.h"
+class Tile : public Sprite
+{
+
+    using TileInfoBody = std::variant<
+        int,
+        std::string>;
+
+private:
+    std::unordered_map<std::string, TileInfoBody> m_data;
+
+public:
+    Tile(/* args */);
+    Tile(std::string Path);
+    ~Tile();
+
+    void SetPos(VecFPos pos) override;
+
+    void InitInfo(std::string Path);
+};