摄像机跟踪的寻路坦克

Author: ccsdu2004

application/CMakeLists.txt

@@ -31,4 +31,6 @@ add_subdirectory(chapter-29)
 add_subdirectory(chapter-30)
 add_subdirectory(chapter-31)
 add_subdirectory(chapter-32)
-add_subdirectory(chapter-33)
+add_subdirectory(chapter-33)
+add_subdirectory(chapter-34)
+add_subdirectory(chapter-35)

application/chapter-25/SpriteForwardState.cpp

@@ -14,7 +14,7 @@ void SpriteForwardState::onEnter()
         return;
 
     auto sprite = std::dynamic_pointer_cast<MovingSprite>(getTarget().lock());
-    auto spritePosition = sprite->getPosition();
+    auto spritePosition = sprite->getCenter();
 
     if(tileMap.expired())
         return;
@@ -39,7 +39,7 @@ void SpriteForwardState::onLeave()
 
     auto sprite = std::dynamic_pointer_cast<MovingSprite>(getTarget().lock());
     sprite->setVelocity(sf::Vector2f(0, 0));
-    sprite->setPosition(targetPosition);
+    sprite->setCenter(targetPosition);
 
     std::shared_ptr<TileMap> tileMapPointer = tileMap.lock();
 
@@ -55,7 +55,7 @@ void SpriteForwardState::update(float deltaTime)
         return;
 
     auto sprite = std::dynamic_pointer_cast<MovingSprite>(getTarget().lock());
-    auto spritePosition = sprite->getPosition();
+    auto spritePosition = sprite->getCenter();
 
     float distance = distance2(targetPosition.x, targetPosition.y, spritePosition.x, spritePosition.y);
     if(distance < 2.0f)

application/chapter-25/SpriteForwardState.h

@@ -6,7 +6,7 @@
 #include <TileMap.h>
 #include <Util.h>
 
-#define FORWARD_SPEED 2.0f
+#define FORWARD_SPEED 1.0f
 
 class SpriteForwardState : public State
 {

application/chapter-25/SpriteIdleState.cpp

@@ -17,8 +17,6 @@ void SpriteIdleState::onEnter()
 void SpriteIdleState::onLeave()
 {
     // std::cout << "enter leave" << std::endl;
-
-
 }
 
 void SpriteIdleState::update(float deltaTime)

application/chapter-25/SpriteRotateState.h

@@ -6,7 +6,7 @@
 #include <StateMachine.h>
 #include <Util.h>
 
-#define ROTATE_SPEED 60.0f
+#define ROTATE_SPEED 24.0f
 
 class SpriteTurnLeftState : public State
 {

application/chapter-25/WayFindingState.cpp

@@ -1,3 +1,4 @@
+#include <iostream>
 #include "WayFindingTileVisitor.h"
 #include "WayFindingState.h"
 
@@ -22,7 +23,7 @@ void WayFindingState::onEnter()
         else
             tank->makeTurnRight();
     } else {
-        auto position = tank->getPosition();
+        auto position = tank->getCenter();
         auto index = tileMapWeak.lock()->getTileIndexByWorldPosition(position.x, position.y);
         tileVisitor.lock()->compute(index);
         onEnter();
@@ -46,7 +47,7 @@ void WayFindingState::update(float deltaTime)
 std::optional<int> WayFindingState::getRotate()
 {
     auto tank = tankWeak.lock();
-    auto position = tank->getPosition();
+    auto position = tank->getCenter();
 
     auto tileMap = tileMapWeak.lock();
     auto index = tileMap->getTileIndexByWorldPosition(position.x, position.y);

application/chapter-25/WayFindingTank.cpp

@@ -17,15 +17,15 @@ WayFindingTank::WayFindingTank(const std::string &image, float x, float y)
     setSize(size.x, size.y);
 }
 
-void WayFindingTank::init(TileMapPointer tileMap)
+void WayFindingTank::init(TileMapPointer inputTileMap)
 {
-    this->tileMap = tileMap;
+    tileMap = inputTileMap;
 
     tankStateMachine = std::make_shared<StateMachine>();
 
     errorState = std::make_shared<SpriteErrorState>();
-    idleState = std::make_shared<SpriteIdleState>(tileMap, shared_from_this());
-    forwardState = std::make_shared<SpriteForwardState>(tileMap, shared_from_this());
+    idleState = std::make_shared<SpriteIdleState>(inputTileMap, shared_from_this());
+    forwardState = std::make_shared<SpriteForwardState>(inputTileMap, shared_from_this());
     turnLeftState = std::make_shared<SpriteTurnLeftState>(shared_from_this());
     turnRightState = std::make_shared<SpriteTurnRightState>(shared_from_this());
 
@@ -79,7 +79,7 @@ std::shared_ptr<State> WayFindingTank::getCurrentState() const
 
 bool WayFindingTank::shouldForward()
 {
-    auto position = getPosition();
+    auto position = getCenter();
     auto tileIndex = tileMap.lock()->getTileIndexByWorldPosition(position.x, position.y);
     int direction = getRotate();
     auto targetTileIndex = tileMap.lock()->getAdjacentTileByDirection(tileIndex.x, tileIndex.y,

application/chapter-25/WayFindingTileVisitor.cpp

@@ -1,4 +1,5 @@
 #include "WayFindingTileVisitor.h"
+#include <iostream>
 
 WayFindingTileVisitor::WayFindingTileVisitor(TileMapPointer inputTileMap)
 {
@@ -8,7 +9,6 @@ WayFindingTileVisitor::WayFindingTileVisitor(TileMapPointer inputTileMap)
 
 void WayFindingTileVisitor::compute(const sf::Vector2i &inputStart)
 {
-    std::cout << inputStart.x << " ->" << inputStart.y << std::endl;
     start = inputStart;
 
     blocks.clear();
@@ -21,7 +21,7 @@ void WayFindingTileVisitor::compute(const sf::Vector2i &inputStart)
     std::vector<uint32_t> output;
     int steps = shortestPathFinder->search(getIDByPosition(inputStart.x, inputStart.y),
                                            getIDByPosition(end.x,
-                                                           end.y), output);
+                                                   end.y), output);
     if (steps > 0) {
         auto itr = output.begin();
         while (itr != output.end()) {

application/chapter-32/main.cpp

@@ -104,6 +104,7 @@ class RectMapScene : public Scene, public TileVisitor
     }
 private:
     std::shared_ptr<TileMap> tileMap;
+    sf::FloatRect tileMapArea;
 };
 
 int main()
@@ -118,7 +119,7 @@ int main()
     Application::getInstance()->setWindow(window);
     auto camera = std::make_shared<Camera>();
     Application::getInstance()->addComponent(camera);
-    camera->setArea(sf::FloatRect(0, 0, APP_SIZE.x, APP_SIZE.y));
+    camera->setWindowArea(sf::FloatRect(0, 0, APP_SIZE.x, APP_SIZE.y));
 
     auto scene = std::make_shared<RectMapScene>();
     auto sceneManager = std::make_shared<SceneManager>();

application/chapter-34/CMakeLists.txt

@@ -0,0 +1,2 @@
+add_executable(chapter-34 main.cpp)
+target_link_libraries(chapter-34 framework sfml-audio sfml-system sfml-graphics sfml-window)

application/chapter-34/main.cpp

@@ -0,0 +1,142 @@
+#include <SFML/Graphics/RenderWindow.hpp>
+#include <Application.h>
+#include <Text.h>
+#include <Scene.h>
+#include <TileMap.h>
+#include <SoundManager.h>
+#include <Camera.h>
+#include <Util.h>
+#include <ResourceManager.h>
+#include <HelpListener.h>
+#include <Widget/Desktop.h>
+#include <Widget/TableLayout.h>
+#include <Widget/ImageBox.h>
+#include <Widget/Label.h>
+#include <Widget/Panel.h>
+#include <CameraTrackingObject.h>
+#include <iostream>
+
+using namespace std;
+
+#define APP_SIZE sf::Vector2f(960,720)
+
+class MouseListener : public MessageListener
+{
+public:
+    MouseListener(TileMapPointer map)
+    {
+        tileMap = map;
+    }
+
+    bool onListener(std::shared_ptr<Message> message) override
+    {
+        if (message->getType() == Message_SFML) {
+            if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left)) {
+                auto camera = Application::getInstance()->getComponent<Camera>();
+                auto view = camera->getView();
+                auto center = view.getCenter();
+                center.x -= 5.0f;
+                camera->setCenter(center);
+            } else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right)) {
+                auto camera = Application::getInstance()->getComponent<Camera>();
+                auto view = camera->getView();
+                auto center = view.getCenter();
+                center.x += 5.0f;
+                camera->setCenter(center);
+            } else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up)) {
+                auto camera = Application::getInstance()->getComponent<Camera>();
+                auto view = camera->getView();
+                auto center = view.getCenter();
+                center.y -= 5.0f;
+                camera->setCenter(center);
+            } else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down)) {
+                auto camera = Application::getInstance()->getComponent<Camera>();
+                auto view = camera->getView();
+                auto center = view.getCenter();
+                center.y += 5.0f;
+                camera->setCenter(center);
+            } else if (sf::Mouse::isButtonPressed(sf::Mouse::Left)) {
+                auto mousePosition = sf::Mouse::getPosition(*Application::getInstance()->getWindow());
+                sf::Vector2f position = Application::getInstance()->getWindow()->mapPixelToCoords(mousePosition);
+                auto index = tileMap.lock()->getTileIndexByWorldPosition(position.x, position.y);
+                auto tile = tileMap.lock()->getTileByIndex(index);
+                if (tile) {
+                    tile->setFillColor(sf::Color::Blue);
+                }
+            }
+            return true;
+        }
+
+        return false;
+    }
+private:
+    std::weak_ptr<TileMap> tileMap;
+};
+
+class RectMapScene : public Scene, public TileVisitor
+{
+public:
+    RectMapScene()
+    {
+        tileMap = TileMap::createTileMap(TileMapType_Hex);
+        tileMap->init(56, 44, 48);
+
+        addChild(tileMap);
+
+        setName("scene");
+
+        auto text = createToastText();
+        text->setText(L"摄像机跟随", false);
+
+        auto cameraTracking = std::make_shared<CameraTrackingObject>();
+        cameraTracking->setTarget(text);
+        cameraTracking->setTargetPosition(sf::Vector2f(20, 20));
+
+        addChild(cameraTracking);
+
+        tileMap->setTextVisible(true);
+        tileMap->accept(this);
+
+        Application::getInstance()->getComponent<Camera>()->setGlobalArea(tileMapArea);
+
+        auto mouseListener = std::make_shared<MouseListener>(tileMap);
+        addMessageListener(mouseListener);
+    }
+
+    void visit(uint32_t x, uint32_t y, std::shared_ptr<Tile> tile) override
+    {
+        (void)x, (void)y;
+        tile->setScale(0.95f, 0.95f);
+        tile->setVisible(true);
+        tile->setFillColor(sf::Color(rand() % 250, rand() % 250, rand() % 250));
+
+        auto box = tile->getGlobalBounds();
+        tileMapArea = expandRect(tileMapArea, box);
+    }
+private:
+    std::shared_ptr<TileMap> tileMap;
+    sf::FloatRect tileMapArea;
+};
+
+int main()
+{
+    auto size = sf::Vector2f(APP_SIZE);
+    auto setting = sf::ContextSettings();
+    setting.antialiasingLevel = 12;
+    auto window = std::make_shared<sf::RenderWindow>(sf::VideoMode(size.x, size.y), "Chapter-34",
+                  sf::Style::Close, setting);
+    window->setVerticalSyncEnabled(true);
+
+    Application::getInstance()->setWindow(window);
+    auto camera = std::make_shared<Camera>();
+    Application::getInstance()->addComponent(camera);
+    camera->setWindowArea(sf::FloatRect(0, 0, APP_SIZE.x, APP_SIZE.y));
+
+    auto scene = std::make_shared<RectMapScene>();
+    auto sceneManager = std::make_shared<SceneManager>();
+    sceneManager->addScene(scene);
+    sceneManager->setInitialScene(scene);
+
+    Application::getInstance()->execute(sceneManager);
+    return 0;
+}

application/chapter-35/CMakeLists.txt

@@ -0,0 +1,21 @@
+
+add_executable(chapter-35 main.cpp
+    SpriteIdleState.h
+    SpriteIdleState.cpp
+    SpriteForwardState.h
+    SpriteForwardState.cpp
+    SpriteRotateState.h
+    SpriteRotateState.cpp
+    SpriteErrorState.h
+    SpriteErrorState.cpp
+    WayFindingScene.cpp
+    WayFindingScene.h
+    WayFindingTank.cpp
+    WayFindingTank.h
+    WayFindingTileVisitor.cpp
+    WayFindingTileVisitor.h
+    WayFindingState.cpp
+    WayFindingState.h
+    )
+
+target_link_libraries(chapter-35 framework sfml-system sfml-graphics sfml-window)

application/chapter-35/SpriteAnimationState.cpp

@@ -0,0 +1,54 @@
+#include <MovingSprite.h>
+#include "MineSweeperScene.h"
+#include "SpriteAnimationState.h"
+
+void SpriteAnimationState::onEnter()
+{
+    if(getTarget().expired())
+        return;
+
+    if(scene.expired())
+        return;
+
+    auto tileMap = scene.lock()->getTileMap();
+    auto sprite = std::dynamic_pointer_cast<Sprite>(getTarget().lock());
+    auto spritePosition = sprite->getPosition();
+    auto tileIndex = tileMap->getTileIndexByWorldPosition(spritePosition.x, spritePosition.y);
+    tileID = getTileIDByPosition(tileIndex.x, tileIndex.y);
+
+    //animation->setPosition(sprite->getPosition().x * 0.5, 0.5 * sprite->getPosition().y);
+    auto box = animation->getBoundingBox();
+    animation->setPosition(box.width, box.height);
+    sprite->addChild(animation);
+    animation->start();
+}
+
+void SpriteAnimationState::onLeave()
+{
+    getTarget().lock()->removeChild(animation);
+    if(scene.expired())
+        return;
+}
+
+void SpriteAnimationState::update(float deltaTime)
+{
+
+}
+
+AnimationPointer SpriteAnimationState::createAnimation()
+{
+    std::vector<sf::IntRect> areas;
+
+    for(int i = 0; i < 6; i++) {
+        auto area = sf::IntRect(i * 85, 0, 85, 85);
+        areas.push_back(area);
+    }
+
+    std::shared_ptr<Animation> animation = std::make_shared<Animation>();
+    animation->setDurationPerFrame(0.2f);
+    animation->setSingleShot(true);
+
+    animation->setBackgroundColor(sf::Color::White);
+    animation->setTexture("../resource/images/blast2.png", areas);
+    return animation;
+}