Merge pull request #14 from idietmoran/dev

added cross-world support for dx11

.gitignore

@@ -3,6 +3,7 @@
 /Release/
 /full release/
 /Output/
+/src/config/
 
 .gitmodules
 packages.config

CHANGELOG.md

@@ -1,6 +1,10 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+## [0.0.6]
+### Added
+- Cross-world party support for DX11
+
 ## [0.0.5]
 ### Added
 - Attempts to bring up users page. If multiple users are found, the search page will be brought up.

README.md

@@ -13,12 +13,12 @@ This program reads the names of party members by memory and opens their username
 [Youtube](https://youtu.be/r9TKVYfq_b0)
 
 #### Known Issues
-- Doesn't update cross-world parties (The memory addresses for cross-world are not static, it's going to take some digging and some patient people)
+- Doesn't update cross-world parties on DX9
 - Lists previous members in the party list until someone new overwrites their position (thank SE for this, still looking for solution)
 
 #### TODO
 ----------------
-- Cross-world Parties  
+- Cross-world Parties for DX9
 - Add stats directly to program  
 - UI  
 

main.cpp

@@ -1,13 +1,8 @@
 #include "src/menu.h"
-#include <thread>
-
 
 int main()
 {
     Menu menu;
-    std::thread t1([=, &menu] { menu.start(); });
-    t1.join();
-
     menu.start();
 
     return 0;

src/arch/arch.cpp

@@ -1,4 +1,5 @@
 #include "arch.h"
+#include <iostream>
 
 
 bool Arch::x64 = false;
@@ -35,11 +36,26 @@ bool Arch::checkArrayForDoubles(std::string name)
     return false;
 }
 
+bool Arch::checkArrayForDoublesCW(std::string name)
+{
+    for (auto &p : filteredAlliesCW_)
+    {
+        if (p->name_ == name)
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
 void Arch::filterAllies()
 {
     filteredAllies_.clear();
+    filteredAlliesCW_.clear();
     //filteredAllies_.reserve(8);
     filteredAllies_.push_back(allies_[0]);
+    filteredAlliesCW_.push_back(alliesCW_[0]);
+
     for (auto &p : allies_)
     {
         // dont add doubles or empty arrays
@@ -48,6 +64,15 @@ void Arch::filterAllies()
             filteredAllies_.push_back(p);
         }
     }
+
+    for(auto &p : alliesCW_)
+    {
+        if(!checkArrayForDoublesCW(p->name_) && p->name_[0] != NULL)
+        {
+            filteredAlliesCW_.push_back(p);
+        }
+    }
+
 }
 
 void Arch::updateNames(Process* proc, int &partyMembers)
@@ -56,14 +81,30 @@ void Arch::updateNames(Process* proc, int &partyMembers)
     {
         ReadProcessMemory(proc->getHandle(), (void*)(exe_->getAddress() + p->address_), &p->name_, 80, 0);
     }
+    for(auto &p : alliesCW_)
+    {
+        ReadProcessMemory(proc->getHandle(), (void*)(p->address_), &p->name_, 80, 0);
+    }
+
     filterAllies();
 
     updateNumberOfPartyMembers(proc, partyMembers);
+    checkCrossWorldParty(proc);
 }
 
 
 
 std::vector<Player*> Arch::getFilteredAllies()
 {
     return filteredAllies_;
+}
+
+std::vector<Player*> Arch::getFilteredAlliesCW()
+{
+    return filteredAlliesCW_;
+}
+
+bool Arch::getCrossWorldStatus()
+{
+    return inCrossWorldParty_;
 }

src/arch/arch.h

@@ -13,18 +13,25 @@ class Arch
 protected:
     Module *exe_;
     Offset *numberOfPartyMembers_;
+    bool inCrossWorldParty_ = false;
     std::vector<Player*> allies_;
     std::vector<Player*> filteredAllies_;
+    std::vector<Player*> alliesCW_;
+    std::vector<Player*> filteredAlliesCW_;
 public:
     Arch();
     virtual ~Arch() = 0;
-    virtual void createAllies() = 0;
+    virtual void createAllies(Process*) = 0;
     virtual void updateNumberOfPartyMembers(Process*, int&) = 0;
+    virtual void checkCrossWorldParty(Process*) = 0;
     static bool x64;
     void deleteAllies();
     bool checkArrayForDoubles(std::string);
+    bool checkArrayForDoublesCW(std::string name);
     void filterAllies();
     void updateNames(Process*, int&);
     std::vector<Player*> getFilteredAllies();
+    std::vector<Player*> getFilteredAlliesCW();
+    bool getCrossWorldStatus();
 };
 

src/arch/x64.cpp

@@ -3,7 +3,7 @@
  * is running in 64-bit, which requires being able to read 64-bit hexadecimal addresses
  */
 #include "x64.h"
-
+#include <iostream>
 
 x64::x64(Process* proc)
 {
@@ -15,7 +15,7 @@ x64::x64(Process* proc)
         Arch::x64 = true;
     }
 
-    createAllies();
+    createAllies(proc);
 }
 
 x64::~x64()
@@ -27,7 +27,7 @@ x64::~x64()
     numberOfPartyMembers_ = nullptr;
 }
 
-void x64::createAllies()
+void x64::createAllies(Process* proc)
 {
     // dx11 64-bit offsets
     allies_.push_back(new YOU(0x1828AE1));
@@ -39,9 +39,28 @@ void x64::createAllies()
     allies_.push_back(new Ally(0x184AC10));
     allies_.push_back(new Ally(0x184A390));
     allies_.push_back(new Ally(0x184AE30));
+
+    alliesCW_.push_back(allies_[0]); // YOU
+    DWORD64 address = exe_->getAddress();
+    address += 0x017E6620;
+
+    ReadProcessMemory(proc->getHandle(), (void*)address, &address, sizeof(DWORD64), 0);
+    address += 0x2E8;
+    alliesCW_.push_back(new Ally(address));
+
+
+    for(int i = 0; i < 6; i++)
+    {
+        alliesCW_.push_back(new Ally(address += 0x48));
+    }
 }
 
 void x64::updateNumberOfPartyMembers(Process* proc, int &partyMembers)
 {
     ReadProcessMemory(proc->getHandle(), (void*)(numberOfPartyMembers_->getMemoryAddress64(proc, exe_)), &partyMembers, sizeof(int), 0);
+}
+
+void x64::checkCrossWorldParty(Process* proc)
+{
+    ReadProcessMemory(proc->getHandle(), (void*)(exe_->getAddress() + 0x1848F0C), &inCrossWorldParty_, 1, 0);
 }

src/arch/x64.h

@@ -7,7 +7,8 @@ class x64 : public Arch
 public:
     x64(Process*);
     ~x64();
-    void createAllies() override;
+    void createAllies(Process*) override;
     void updateNumberOfPartyMembers(Process*, int&) override;
+    void checkCrossWorldParty(Process*) override;
 };
 

src/arch/x86.cpp

@@ -21,7 +21,7 @@ x86::x86(Process* proc)
         Sleep(3000);
         exit(0);
     }
-    createAllies();
+    createAllies(proc);
 }
 
 
@@ -34,7 +34,7 @@ x86::~x86()
     numberOfPartyMembers_ = nullptr;
 }
 
-void x86::createAllies()
+void x86::createAllies(Process* proc)
 {
     allies_.reserve(8);
     // dx9 32-bit offsets
@@ -53,4 +53,9 @@ void x86::createAllies()
 void x86::updateNumberOfPartyMembers(Process *proc, int &partyMembers)
 {
     ReadProcessMemory(proc->getHandle(), (void*)(numberOfPartyMembers_->getMemoryAddress(proc, exe_)), &partyMembers, sizeof(int), 0);
+}
+
+void x86::checkCrossWorldParty(Process* proc)
+{
+    // do nothing for the time being
 }

src/arch/x86.h

@@ -7,6 +7,7 @@ class x86 : public Arch
     x86(Process*);
     ~x86();
     void updateNumberOfPartyMembers(Process*, int&) override;
-    void createAllies() override;
+    void createAllies(Process*) override;
+    void checkCrossWorldParty(Process* proc) override;
 };
 

src/menu.cpp

@@ -22,28 +22,64 @@ void Menu::displayAllies()
     // update play characters names
     fflogs_->arch_->updateNames(fflogs_->ffxiv_, fflogs_->partyMembers_);
 
-
+    int partyMembers = fflogs_->partyMembers_;
     SetConsoleTextAttribute(hConsole_, 7);
     // display title
     std::cout << "FFXIV Party Logs\n";
-    std::cout << "--------------------\n";
+    std::cout << "--------------------";
 
-    /*
-     * NOTE: It's impossible to determine people no longer in the party without parsing the chat log
-     * TODO: Maybe in the future
-     */
+    if(fflogs_->arch_->getCrossWorldStatus())
+    {
+        SetConsoleTextAttribute(hConsole_, 13);
+        std::cout << "\nCROSSWORLD PARTY" << std::endl;
+
+        if(fflogs_->arch_->getFilteredAlliesCW().size() < fflogs_->partyMembers_)
+        {
+            partyMembers = fflogs_->arch_->getFilteredAlliesCW().size();
+        }
 
-    for (int i = 0; i < fflogs_->arch_->getFilteredAllies().size(); i++)
+        for (int i = 0; i < partyMembers; i++)
+        {
+            SetConsoleTextAttribute(hConsole_, 7);
+            // highlight current line
+            if (i == currentMenuSelection_)
+            {
+                SetConsoleTextAttribute(hConsole_, 23);
+            }
+            fflogs_->arch_->getFilteredAlliesCW()[i]->display();
+        }
+        // this prevents the colors from breaking
+
+    }
+    // if normal party
+    else
     {
-        SetConsoleTextAttribute(hConsole_, 7);
-        if (i == currentMenuSelection_)
+        SetConsoleTextAttribute(hConsole_, 3);
+        std::cout << "\nNORMAL PARTY" << std::endl;
+
+        if (fflogs_->arch_->getFilteredAllies().size() < fflogs_->partyMembers_)
         {
-            SetConsoleTextAttribute(hConsole_, 23);
+            partyMembers = fflogs_->arch_->getFilteredAllies().size();
         }
-        //fflogs_->arch_->getFilteredAllies()[i]->display();
-        fflogs_->arch_->getFilteredAllies()[i]->display();
+
+        for (int i = 0; i < partyMembers; i++)
+        {
+            SetConsoleTextAttribute(hConsole_, 7);
+            // higlight current line
+            if (i == currentMenuSelection_)
+            {
+                SetConsoleTextAttribute(hConsole_, 23); 
+            }
+            fflogs_->arch_->getFilteredAllies()[i]->display();
+        }
+        // this prevents the colors from breaking
     }
-    // this prevents the colors from breaking
+    /*
+     * NOTE: It's impossible to determine people no longer in the party without parsing the chat log
+     * TODO: Maybe in the future
+     */
+
+
     SetConsoleTextAttribute(hConsole_, 7);
 }
 
@@ -61,13 +97,18 @@ void Menu::alliesMenu(DWORD &mode, INPUT_RECORD &event, HANDLE &hstdin)
     system("CLS");
     displayAllies();
     prevPartySize_ = fflogs_->partyMembers_;
+    prevCrossWorldStatus_ = fflogs_->arch_->getCrossWorldStatus();
 
     while(live_)
     {
+        fflogs_->arch_->updateNames(fflogs_->ffxiv_, fflogs_->partyMembers_);
 
-        if(prevPartySize_ != fflogs_->partyMembers_)
+
+        // checks if party size changes, or party changes to crossworld and displays the changes
+        if(prevPartySize_ != fflogs_->partyMembers_ || prevCrossWorldStatus_ != fflogs_->arch_->getCrossWorldStatus())
         {
             prevPartySize_ = fflogs_->partyMembers_;
+            prevCrossWorldStatus_ = fflogs_->arch_->getCrossWorldStatus();
             redraw();
         }
 
@@ -89,7 +130,7 @@ void Menu::alliesMenu(DWORD &mode, INPUT_RECORD &event, HANDLE &hstdin)
 
         if(GetAsyncKeyState(VK_DOWN) & 0x1 && isConsoleWindowFocussed)
         {
-            if (currentMenuSelection_ < fflogs_->arch_->getFilteredAllies().size() - 1)
+            if (currentMenuSelection_ < fflogs_->partyMembers_ - 1)
             {
                 currentMenuSelection_++;
                 redraw();
@@ -98,9 +139,15 @@ void Menu::alliesMenu(DWORD &mode, INPUT_RECORD &event, HANDLE &hstdin)
 
         if(GetAsyncKeyState(VK_RETURN) & 0x1 && isConsoleWindowFocussed)
         {
-            fflogs_->arch_->getFilteredAllies()[currentMenuSelection_]->openBrowser();
+            if(fflogs_->arch_->getCrossWorldStatus())
+            {
+                fflogs_->arch_->getFilteredAlliesCW()[currentMenuSelection_]->openBrowser();
+            }
+            else
+            {
+                fflogs_->arch_->getFilteredAllies()[currentMenuSelection_]->openBrowser();
+            }
         }
-
         Sleep(1);
     }
 }