restructure codebase according to vcproj filters

Minecraft.Client/Common/Source Files/Tutorial/Hints/AreaHint.cpp

@@ -0,0 +1,41 @@
+#include "../../../../../Minecraft.World/Header Files/stdafx.h"
+
+#include "../../../../net/minecraft/client/Minecraft.h"
+#include "../../../../net/minecraft/client/multiplayer/MultiPlayerLocalPlayer.h"
+#include "AreaHint.h"
+#include "../../../../../Minecraft.World/net/minecraft/world/phys/AABB.h"
+#include "../Tutorial.h"
+
+AreaHint::AreaHint(eTutorial_Hint id, Tutorial* tutorial,
+                   eTutorial_State displayState, eTutorial_State completeState,
+                   int descriptionId, double x0, double y0, double z0,
+                   double x1, double y1, double z1, bool allowFade /*= false*/,
+                   bool contains /*= true*/)
+    : TutorialHint(id, tutorial, descriptionId, e_Hint_Area, allowFade) {
+    area = AABB(x0, y0, z0, x1, y1, z1);
+
+    this->contains = contains;
+
+    m_displayState = displayState;
+    m_completeState = completeState;
+}
+
+int AreaHint::tick() {
+    Minecraft* minecraft = Minecraft::GetInstance();
+    Vec3 player_pos = minecraft->player->getPos(1);
+
+    if ((m_displayState == e_Tutorial_State_Any ||
+         m_tutorial->getCurrentState() == m_displayState) &&
+        m_hintNeeded && area.contains(player_pos) == contains) {
+        if (m_completeState == e_Tutorial_State_None) {
+            m_hintNeeded = false;
+        } else if (m_tutorial->isStateCompleted(m_completeState)) {
+            m_hintNeeded = false;
+            return -1;
+        }
+
+        return m_descriptionId;
+    } else {
+        return -1;
+    }
+}

Minecraft.Client/Common/Source Files/Tutorial/Hints/AreaHint.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "TutorialHint.h"
+
+class AABB;
+
+class AreaHint : public TutorialHint {
+private:
+    AABB area;
+    bool contains;  // If true we must stay in this area, if false must stay out
+                    // of this area
+
+    // Only display the hint if the game is in this state
+    eTutorial_State m_displayState;
+
+    // Only display the hint if this state is not completed
+    eTutorial_State m_completeState;
+
+public:
+    AreaHint(eTutorial_Hint id, Tutorial* tutorial,
+             eTutorial_State displayState, eTutorial_State completeState,
+             int descriptionId, double x0, double y0, double z0, double x1,
+             double y1, double z1, bool allowFade = true, bool contains = true);
+
+    virtual int tick();
+};

Minecraft.Client/Common/Source Files/Tutorial/Hints/DiggerItemHint.cpp

@@ -0,0 +1,64 @@
+#include "../../../../../Minecraft.World/Header Files/stdafx.h"
+#include "../../../../../Minecraft.World/net/minecraft/world/level/net.minecraft.world.level.h"
+#include "../../../../../Minecraft.World/net/minecraft/world/level/tile/net.minecraft.world.level.tile.h"
+#include "../../../../../Minecraft.World/net/minecraft/world/item/net.minecraft.world.item.h"
+#include "../../../../../Minecraft.World/net/minecraft/world/entity/net.minecraft.world.entity.h"
+#include "../Tutorial.h"
+#include "DiggerItemHint.h"
+
+DiggerItemHint::DiggerItemHint(eTutorial_Hint id, Tutorial* tutorial,
+                               int descriptionId, int items[],
+                               unsigned int itemsLength)
+    : TutorialHint(id, tutorial, descriptionId, e_Hint_DiggerItem) {
+    m_iItemsCount = itemsLength;
+
+    m_iItems = new int[m_iItemsCount];
+    for (unsigned int i = 0; i < m_iItemsCount; i++) {
+        m_iItems[i] = items[i];
+    }
+    tutorial->addMessage(IDS_TUTORIAL_HINT_ATTACK_WITH_TOOL, true);
+}
+
+int DiggerItemHint::startDestroyBlock(std::shared_ptr<ItemInstance> item,
+                                      Tile* tile) {
+    if (item != nullptr) {
+        bool itemFound = false;
+        for (unsigned int i = 0; i < m_iItemsCount; i++) {
+            if (item->id == m_iItems[i]) {
+                itemFound = true;
+                break;
+            }
+        }
+        if (itemFound) {
+            float speed = item->getDestroySpeed(tile);
+            if (speed == 1) {
+                // Display hint
+                return m_descriptionId;
+            }
+        }
+    }
+    return -1;
+}
+
+int DiggerItemHint::attack(std::shared_ptr<ItemInstance> item,
+                           std::shared_ptr<Entity> entity) {
+    if (item != nullptr) {
+        bool itemFound = false;
+        for (unsigned int i = 0; i < m_iItemsCount; i++) {
+            if (item->id == m_iItems[i]) {
+                itemFound = true;
+                break;
+            }
+        }
+        if (itemFound) {
+            // It's also possible that we could hit TileEntities (eg falling
+            // sand) so don't want to give this hint then
+            if (entity->instanceof(eTYPE_MOB)) {
+                return IDS_TUTORIAL_HINT_ATTACK_WITH_TOOL;
+            } else {
+                return -1;
+            }
+        }
+    }
+    return -1;
+}

Minecraft.Client/Common/Source Files/Tutorial/Hints/DiggerItemHint.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "TutorialHint.h"
+
+class DiggerItem;
+class Level;
+
+class DiggerItemHint : public TutorialHint {
+private:
+    int* m_iItems;
+    unsigned int m_iItemsCount;
+
+public:
+    DiggerItemHint(eTutorial_Hint id, Tutorial* tutorial, int descriptionId,
+                   int items[], unsigned int itemsLength);
+    virtual int startDestroyBlock(std::shared_ptr<ItemInstance> item,
+                                  Tile* tile);
+    virtual int attack(std::shared_ptr<ItemInstance> item,
+                       std::shared_ptr<Entity> entity);
+};

Minecraft.Client/Common/Source Files/Tutorial/Hints/LookAtEntityHint.cpp

@@ -0,0 +1,24 @@
+#include "../../../../../Minecraft.World/Header Files/stdafx.h"
+#include "../Tutorial.h"
+#include "LookAtEntityHint.h"
+
+LookAtEntityHint::LookAtEntityHint(eTutorial_Hint id, Tutorial* tutorial,
+                                   int descriptionId, int titleId,
+                                   eINSTANCEOF type)
+    : TutorialHint(id, tutorial, descriptionId, e_Hint_LookAtEntity) {
+    m_type = type;
+    m_titleId = titleId;
+}
+
+bool LookAtEntityHint::onLookAtEntity(eINSTANCEOF type) {
+    if (m_type == type) {
+        // Display hint
+        Tutorial::PopupMessageDetails* message =
+            new Tutorial::PopupMessageDetails();
+        message->m_messageId = m_descriptionId;
+        message->m_titleId = m_titleId;
+        message->m_delay = true;
+        return m_tutorial->setMessage(this, message);
+    }
+    return false;
+}

Minecraft.Client/Common/Source Files/Tutorial/Hints/LookAtEntityHint.h

@@ -0,0 +1,21 @@
+#pragma once
+// using namespace std;
+
+#include "../../../../../Minecraft.World/ConsoleJavaLibs/Class.h"
+#include "TutorialHint.h"
+
+class ItemInstance;
+
+class LookAtEntityHint : public TutorialHint {
+private:
+    eINSTANCEOF m_type;
+    int m_titleId;
+
+public:
+    LookAtEntityHint(eTutorial_Hint id, Tutorial* tutorial, int descriptionId,
+                     int titleId, eINSTANCEOF type);
+    // TODO: 4jcraft added, this was not implemented
+    ~LookAtEntityHint() {};
+
+    virtual bool onLookAtEntity(eINSTANCEOF type);
+};

Minecraft.Client/Common/Source Files/Tutorial/Hints/LookAtTileHint.cpp

@@ -0,0 +1,59 @@
+#include "../../../../../Minecraft.World/Header Files/stdafx.h"
+#include "../../../../../Minecraft.World/net/minecraft/world/item/net.minecraft.world.item.h"
+#include "../../../../../Minecraft.World/net/minecraft/world/level/tile/net.minecraft.world.level.tile.h"
+#include "../Tutorial.h"
+#include "LookAtTileHint.h"
+
+LookAtTileHint::LookAtTileHint(eTutorial_Hint id, Tutorial* tutorial,
+                               int tiles[], unsigned int tilesLength,
+                               int iconOverride /*= -1*/, int iData /* = -1 */,
+                               int iDataOverride /*= -1*/)
+    : TutorialHint(id, tutorial, -1, e_Hint_LookAtTile) {
+    m_iTilesCount = tilesLength;
+
+    // TODO: 4jcraft: allocating but never freeing mem, leak
+    m_iTiles = new int[m_iTilesCount];
+    for (unsigned int i = 0; i < m_iTilesCount; i++) {
+        m_iTiles[i] = tiles[i];
+    }
+
+    m_iconOverride = iconOverride;
+    m_iData = iData;
+    m_iDataOverride = iDataOverride;
+}
+
+bool LookAtTileHint::onLookAt(int id, int iData) {
+    if (id > 0 && id < 256 && (m_iData == -1 || m_iData == iData)) {
+        bool itemFound = false;
+        for (unsigned int i = 0; i < m_iTilesCount; i++) {
+            if (id == m_iTiles[i]) {
+                itemFound = true;
+                break;
+            }
+        }
+        if (itemFound) {
+            // Display hint
+            Tutorial::PopupMessageDetails* message =
+                new Tutorial::PopupMessageDetails();
+            message->m_delay = true;
+            if (m_iconOverride >= 0) {
+                message->m_icon = m_iconOverride;
+            } else if (m_iconOverride == -2) {
+                message->m_icon = TUTORIAL_NO_ICON;
+            } else {
+                message->m_icon = id;
+            }
+
+            // 4J-JEV: Moved to keep data override even if we're overriding the
+            // icon as well.
+            message->m_iAuxVal =
+                (m_iDataOverride > -1) ? m_iDataOverride : iData;
+
+            message->m_messageId = Item::items[id]->getUseDescriptionId();
+            message->m_titleId =
+                Item::items[id]->getDescriptionId(message->m_iAuxVal);
+            return m_tutorial->setMessage(this, message);
+        }
+    }
+    return false;
+}

Minecraft.Client/Common/Source Files/Tutorial/Hints/LookAtTileHint.h

@@ -0,0 +1,24 @@
+#pragma once
+// using namespace std;
+
+#include "TutorialHint.h"
+
+class ItemInstance;
+
+class LookAtTileHint : public TutorialHint {
+private:
+    int* m_iTiles;
+    unsigned int m_iTilesCount;
+    int m_iconOverride;
+    int m_iData;
+    int m_iDataOverride;
+
+public:
+    LookAtTileHint(eTutorial_Hint id, Tutorial* tutorial, int tiles[],
+                   unsigned int tilesLength, int iconOverride = -1,
+                   int iData = -1, int iDataOverride = -1);
+    // TODO: 4jcraft, added, destructor was never implemented
+    ~LookAtTileHint() {};
+
+    virtual bool onLookAt(int id, int iData = 0);
+};

Minecraft.Client/Common/Source Files/Tutorial/Hints/TakeItemHint.cpp

@@ -0,0 +1,39 @@
+#include "../../../../../Minecraft.World/Header Files/stdafx.h"
+#include "../../../../../Minecraft.World/net/minecraft/world/item/net.minecraft.world.item.h"
+#include "../../../../../Minecraft.World/net/minecraft/world/level/tile/net.minecraft.world.level.tile.h"
+#include "../Tutorial.h"
+#include "TakeItemHint.h"
+
+TakeItemHint::TakeItemHint(eTutorial_Hint id, Tutorial* tutorial, int items[],
+                           unsigned int itemsLength)
+    : TutorialHint(id, tutorial, -1, e_Hint_TakeItem) {
+    m_iItemsCount = itemsLength;
+
+    m_iItems = new int[m_iItemsCount];
+    for (unsigned int i = 0; i < m_iItemsCount; i++) {
+        m_iItems[i] = items[i];
+    }
+}
+
+bool TakeItemHint::onTake(std::shared_ptr<ItemInstance> item) {
+    if (item != nullptr) {
+        bool itemFound = false;
+        for (unsigned int i = 0; i < m_iItemsCount; i++) {
+            if (item->id == m_iItems[i]) {
+                itemFound = true;
+                break;
+            }
+        }
+        if (itemFound) {
+            // Display hint
+            Tutorial::PopupMessageDetails* message =
+                new Tutorial::PopupMessageDetails();
+            message->m_messageId = item->getUseDescriptionId();
+            message->m_titleId = item->getDescriptionId();
+            message->m_icon = item->id;
+            message->m_delay = true;
+            return m_tutorial->setMessage(this, message);
+        }
+    }
+    return false;
+}

Minecraft.Client/Common/Source Files/Tutorial/Hints/TakeItemHint.h

@@ -0,0 +1,20 @@
+#pragma once
+// using namespace std;
+
+#include "TutorialHint.h"
+
+class ItemInstance;
+
+class TakeItemHint : public TutorialHint {
+private:
+    int* m_iItems;
+    unsigned int m_iItemsCount;
+
+public:
+    TakeItemHint(eTutorial_Hint id, Tutorial* tutorial, int items[],
+                 unsigned int itemsLength);
+    // TODO: 4jcraft, added, it was never implemented
+    virtual ~TakeItemHint() {};
+
+    virtual bool onTake(std::shared_ptr<ItemInstance> item);
+};

Minecraft.Client/Common/Source Files/Tutorial/Hints/TutorialHint.cpp

@@ -0,0 +1,117 @@
+#include "../../../../../Minecraft.World/Header Files/stdafx.h"
+#include "../../../../../Minecraft.World/net/minecraft/world/level/net.minecraft.world.level.h"
+#include "../../../../../Minecraft.World/net/minecraft/world/level/tile/net.minecraft.world.level.tile.h"
+#include "../../../../../Minecraft.World/net/minecraft/world/item/net.minecraft.world.item.h"
+#include "../Tutorial.h"
+#include "TutorialHint.h"
+#include "../../../../net/minecraft/client/Minecraft.h"
+#include "../../../../net/minecraft/client/multiplayer/MultiPlayerLocalPlayer.h"
+
+TutorialHint::TutorialHint(eTutorial_Hint id, Tutorial* tutorial,
+                           int descriptionId, eHintType type,
+                           bool allowFade /*= true*/)
+    : m_id(id),
+      m_tutorial(tutorial),
+      m_descriptionId(descriptionId),
+      m_type(type),
+      m_counter(0),
+      m_lastTile(nullptr),
+      m_hintNeeded(true),
+      m_allowFade(allowFade) {
+    tutorial->addMessage(descriptionId, type != e_Hint_NoIngredients);
+}
+
+int TutorialHint::startDestroyBlock(std::shared_ptr<ItemInstance> item,
+                                    Tile* tile) {
+    int returnVal = -1;
+    switch (m_type) {
+        case e_Hint_HoldToMine:
+            if (tile == m_lastTile && m_hintNeeded) {
+                ++m_counter;
+                if (m_counter > TUTORIAL_HINT_MAX_MINE_REPEATS) {
+                    returnVal = m_descriptionId;
+                }
+            } else {
+                m_counter = 0;
+            }
+            m_lastTile = tile;
+            break;
+        default:
+            break;
+    }
+
+    return returnVal;
+}
+
+int TutorialHint::destroyBlock(Tile* tile) {
+    int returnVal = -1;
+    switch (m_type) {
+        case e_Hint_HoldToMine:
+            if (tile == m_lastTile && m_counter > 0) {
+                m_hintNeeded = false;
+            }
+            break;
+        default:
+            break;
+    }
+
+    return returnVal;
+}
+
+int TutorialHint::attack(std::shared_ptr<ItemInstance> item,
+                         std::shared_ptr<Entity> entity) {
+    /*
+    switch(m_type)
+    {
+    default:
+            return -1;
+    }
+    */
+    return -1;
+}
+
+int TutorialHint::createItemSelected(std::shared_ptr<ItemInstance> item,
+                                     bool canMake) {
+    int returnVal = -1;
+    switch (m_type) {
+        case e_Hint_NoIngredients:
+            if (!canMake) returnVal = m_descriptionId;
+            break;
+        default:
+            break;
+    }
+    return returnVal;
+}
+
+int TutorialHint::itemDamaged(std::shared_ptr<ItemInstance> item) {
+    int returnVal = -1;
+    switch (m_type) {
+        case e_Hint_ToolDamaged:
+            returnVal = m_descriptionId;
+            break;
+        default:
+            break;
+    }
+    return returnVal;
+}
+
+bool TutorialHint::onTake(std::shared_ptr<ItemInstance> item) { return false; }
+
+bool TutorialHint::onLookAt(int id, int iData) { return false; }
+
+bool TutorialHint::onLookAtEntity(eINSTANCEOF type) { return false; }
+
+int TutorialHint::tick() {
+    int returnVal = -1;
+    switch (m_type) {
+        case e_Hint_SwimUp:
+            if (Minecraft::GetInstance()
+                    ->localplayers[m_tutorial->getPad()]
+                    ->isUnderLiquid(Material::water))
+                returnVal = m_descriptionId;
+            break;
+        default:
+            break;
+    }
+    return returnVal;
+}

Minecraft.Client/Common/Source Files/Tutorial/Hints/TutorialHint.h

@@ -0,0 +1,56 @@
+#pragma once
+// using namespace std;
+
+#include "../TutorialEnum.h"
+
+#define TUTORIAL_HINT_MAX_MINE_REPEATS 20
+
+class Level;
+class Tutorial;
+
+class TutorialHint {
+public:
+    enum eHintType {
+        e_Hint_DiggerItem,
+        e_Hint_HoldToMine,
+        e_Hint_NoIngredients,
+        e_Hint_ToolDamaged,
+        e_Hint_TakeItem,
+        e_Hint_Area,
+        e_Hint_LookAtTile,
+        e_Hint_LookAtEntity,
+        e_Hint_SwimUp,
+    };
+
+protected:
+    eHintType m_type;
+    int m_descriptionId;
+    Tutorial* m_tutorial;
+    eTutorial_Hint m_id;
+
+    int m_counter;
+    Tile* m_lastTile;
+    bool m_hintNeeded;
+    bool m_allowFade;
+
+public:
+    TutorialHint(eTutorial_Hint id, Tutorial* tutorial, int descriptionId,
+                 eHintType type, bool allowFade = true);
+    virtual ~TutorialHint() {}
+
+    eTutorial_Hint getId() { return m_id; }
+
+    virtual int startDestroyBlock(std::shared_ptr<ItemInstance> item,
+                                  Tile* tile);
+    virtual int destroyBlock(Tile* tile);
+    virtual int attack(std::shared_ptr<ItemInstance> item,
+                       std::shared_ptr<Entity> entity);
+    virtual int createItemSelected(std::shared_ptr<ItemInstance> item,
+                                   bool canMake);
+    virtual int itemDamaged(std::shared_ptr<ItemInstance> item);
+    virtual bool onTake(std::shared_ptr<ItemInstance> item);
+    virtual bool onLookAt(int id, int iData = 0);
+    virtual bool onLookAtEntity(eINSTANCEOF type);
+    virtual int tick();
+    virtual bool allowFade() { return m_allowFade; }
+};

Minecraft.Client/Common/Source Files/Tutorial/Hints/TutorialHints.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include "AreaHint.h"
+#include "DiggerItemHint.h"
+#include "LookAtTileHint.h"
+#include "TakeItemHint.h"
+#include "LookAtEntityHint.h"