1
0
Fork 0
forked from aly/qstbak

qstcompanion v1.0.5

This commit is contained in:
alydev 2025-12-04 04:40:50 +10:00
parent 52daefcfd7
commit 5e1e1decc5
9 changed files with 304 additions and 200 deletions

View file

@ -18,7 +18,7 @@ public class MSQProgressionService
private readonly QuestDetectionService questDetectionService;
private readonly IClientState clientState;
private readonly IObjectTable objectTable;
private readonly IFramework framework;
@ -96,12 +96,12 @@ public class MSQProgressionService
}
};
public MSQProgressionService(IDataManager dataManager, IPluginLog log, QuestDetectionService questDetectionService, IClientState clientState, IFramework framework)
public MSQProgressionService(IDataManager dataManager, IPluginLog log, QuestDetectionService questDetectionService, IObjectTable objectTable, IFramework framework)
{
this.dataManager = dataManager;
this.log = log;
this.questDetectionService = questDetectionService;
this.clientState = clientState;
this.objectTable = objectTable;
this.framework = framework;
InitializeMSQData();
framework.RunOnTick(delegate
@ -114,95 +114,68 @@ public class MSQProgressionService
{
try
{
log.Information("[MSQProgression] === INITIALIZING MSQ DATA ===");
ExcelSheet<Quest> questSheet = dataManager.GetExcelSheet<Quest>();
if (questSheet == null)
{
log.Error("[MSQProgression] Failed to load Quest sheet from Lumina!");
return;
}
int totalQuests = questSheet.Count();
log.Information($"[MSQProgression] ✓ Lumina Quest Sheet loaded: {totalQuests} total quests");
questSheet.Count();
int manualCount = 0;
foreach (Quest item in questSheet)
{
_ = item;
manualCount++;
}
log.Information($"[MSQProgression] Manual iteration count: {manualCount} quests");
List<Quest> highIdQuests = questSheet.Where((Quest q) => q.RowId > 66000).ToList();
log.Information($"[MSQProgression] Quests with RowId > 66000: {highIdQuests.Count}");
if (highIdQuests.Count > 0)
{
Quest firstHighId = highIdQuests.First();
log.Information($"[MSQProgression] First High ID Quest: {firstHighId.RowId}");
log.Information($"[MSQProgression] - Name: {firstHighId.Name}");
log.Information($"[MSQProgression] - Expansion.RowId: {firstHighId.Expansion.RowId}");
log.Information($"[MSQProgression] - JournalGenre.RowId: {firstHighId.JournalGenre.RowId}");
highIdQuests.First();
}
log.Information("[MSQProgression] Analyzing JournalGenre distribution...");
foreach (IGrouping<uint, Quest> group in (from q in questSheet
foreach (IGrouping<uint, Quest> item2 in (from q in questSheet
where q.RowId != 0
group q by q.JournalGenre.RowId into g
orderby g.Key
select g).Take(10))
{
log.Information($"[MSQProgression] Genre {group.Key}: {group.Count()} quests");
_ = item2;
}
log.Information("[MSQProgression] Filtering MSQ quests by JournalGenre categories (1-14)...");
mainScenarioQuests = (from q in questSheet
where ((ReadOnlySpan<uint>)MSQ_JOURNAL_GENRE_IDS).Contains(q.JournalGenre.RowId)
orderby q.RowId
select q).ToList();
log.Information($"[MSQProgression] ✓ Found {mainScenarioQuests.Count} total MSQ quests across all expansions!");
if (mainScenarioQuests.Count == 0)
{
log.Error("[MSQProgression] No MSQ quests found! JournalGenre filter may be incorrect.");
return;
}
log.Information("[MSQProgression] === DETAILED MSQ QUEST ANALYSIS (First 20) ===");
foreach (Quest quest in mainScenarioQuests.Take(20))
{
log.Information($"[MSQProgression] Quest {quest.RowId}:");
log.Information($"[MSQProgression] - Name: {quest.Name}");
log.Information($"[MSQProgression] - Expansion.RowId: {quest.Expansion.RowId}");
try
{
string expansionName = quest.Expansion.Value.Name.ToString();
log.Information("[MSQProgression] - Expansion.Name: " + expansionName);
quest.Expansion.Value.Name.ToString();
}
catch (Exception ex)
catch (Exception)
{
log.Information("[MSQProgression] - Expansion.Name: ERROR - " + ex.Message);
}
log.Information($"[MSQProgression] - JournalGenre.RowId: {quest.JournalGenre.RowId}");
}
log.Information("[MSQProgression] === MSQ QUESTS BY JOURNALGENRE (EXPANSION) ===");
foreach (IGrouping<uint, Quest> group2 in from q in mainScenarioQuests
foreach (IGrouping<uint, Quest> group in from q in mainScenarioQuests
group q by q.JournalGenre.RowId into g
orderby g.Key
select g)
{
uint genreId = group2.Key;
MSQExpansionData.Expansion expansion = JournalGenreToExpansion.GetValueOrDefault(genreId, MSQExpansionData.Expansion.ARealmReborn);
string genreName = group2.First().JournalGenre.Value.Name.ToString();
string sampleQuests = string.Join(", ", from q in group2.Take(3)
uint genreId = group.Key;
JournalGenreToExpansion.GetValueOrDefault(genreId, MSQExpansionData.Expansion.ARealmReborn);
group.First().JournalGenre.Value.Name.ToString();
string.Join(", ", from q in @group.Take(3)
select q.RowId);
log.Information($"[MSQProgression] JournalGenre {genreId} ({expansion}):");
log.Information("[MSQProgression] - Name: " + genreName);
log.Information($"[MSQProgression] - Count: {group2.Count()} quests");
log.Information("[MSQProgression] - Samples: " + sampleQuests + "...");
}
log.Information("[MSQProgression] === MSQ QUESTS BY EXPANSION (GROUPED) ===");
foreach (IGrouping<MSQExpansionData.Expansion, Quest> group3 in from q in mainScenarioQuests
foreach (IGrouping<MSQExpansionData.Expansion, Quest> item3 in from q in mainScenarioQuests
group q by JournalGenreToExpansion.GetValueOrDefault(q.JournalGenre.RowId, MSQExpansionData.Expansion.ARealmReborn) into g
orderby g.Key
select g)
{
log.Information($"[MSQProgression] {group3.Key}: {group3.Count()} quests total");
_ = item3;
}
MSQExpansionData.ClearQuests();
log.Information("[MSQProgression] Building expansion quest mappings...");
foreach (Quest quest2 in mainScenarioQuests)
{
string name = quest2.Name.ToString();
@ -210,11 +183,11 @@ public class MSQProgressionService
{
questNameCache[quest2.RowId] = name;
}
MSQExpansionData.Expansion expansion2 = JournalGenreToExpansion.GetValueOrDefault(quest2.JournalGenre.RowId, MSQExpansionData.Expansion.ARealmReborn);
MSQExpansionData.Expansion expansion = JournalGenreToExpansion.GetValueOrDefault(quest2.JournalGenre.RowId, MSQExpansionData.Expansion.ARealmReborn);
if (quest2.JournalGenre.RowId != 2 || quest2.RowId <= 65964)
{
MSQExpansionData.RegisterQuest(quest2.RowId, expansion2);
string shortName = MSQExpansionData.GetExpansionShortName(expansion2);
MSQExpansionData.RegisterQuest(quest2.RowId, expansion);
string shortName = MSQExpansionData.GetExpansionShortName(expansion);
if (!questsByExpansion.ContainsKey(shortName))
{
questsByExpansion[shortName] = new List<Quest>();
@ -222,29 +195,19 @@ public class MSQProgressionService
questsByExpansion[shortName].Add(quest2);
}
}
log.Information("[MSQProgression] === EXPANSION BREAKDOWN ===");
foreach (MSQExpansionData.Expansion exp in MSQExpansionData.GetAllExpansions())
foreach (MSQExpansionData.Expansion allExpansion in MSQExpansionData.GetAllExpansions())
{
string shortName2 = MSQExpansionData.GetExpansionShortName(exp);
string shortName2 = MSQExpansionData.GetExpansionShortName(allExpansion);
List<Quest> quests = questsByExpansion.GetValueOrDefault(shortName2);
int count = quests?.Count ?? 0;
if (count > 0 && quests != null)
if ((quests?.Count ?? 0) > 0 && quests != null)
{
string sampleIds = string.Join(", ", from q in quests.Take(5)
string.Join(", ", from q in quests.Take(5)
select q.RowId);
log.Information($"[MSQProgression] ✓ {MSQExpansionData.GetExpansionName(exp)} ({shortName2}): {count} quests (IDs: {sampleIds}...)");
}
else
{
log.Warning($"[MSQProgression] ⚠ {MSQExpansionData.GetExpansionName(exp)} ({shortName2}): {count} quests (EMPTY!)");
}
}
log.Information("[MSQProgression] === MSQ DATA INITIALIZATION COMPLETE ===");
}
catch (Exception ex2)
catch (Exception)
{
log.Error("[MSQProgression] EXCEPTION during MSQ data initialization: " + ex2.Message);
log.Error("[MSQProgression] Stack trace: " + ex2.StackTrace);
}
}
@ -267,9 +230,8 @@ public class MSQProgressionService
return (questId: lastMSQ.RowId, questName: questName);
}
}
catch (Exception ex)
catch (Exception)
{
log.Error("[MSQProgression] Failed to get last completed MSQ: " + ex.Message);
}
return (questId: 0u, questName: "—");
}
@ -285,9 +247,8 @@ public class MSQProgressionService
List<uint> completedQuests = questDetectionService.GetAllCompletedQuestIds();
return (float)mainScenarioQuests.Count((Quest q) => completedQuests.Contains(q.RowId)) / (float)mainScenarioQuests.Count * 100f;
}
catch (Exception ex)
catch (Exception)
{
log.Error("[MSQProgression] Failed to calculate MSQ completion: " + ex.Message);
return 0f;
}
}
@ -308,9 +269,8 @@ public class MSQProgressionService
List<uint> completedQuests = questDetectionService.GetAllCompletedQuestIds();
return mainScenarioQuests.Count((Quest q) => completedQuests.Contains(q.RowId));
}
catch (Exception ex)
catch (Exception)
{
log.Error("[MSQProgression] Failed to get completed MSQ count: " + ex.Message);
return 0;
}
}
@ -364,49 +324,25 @@ public class MSQProgressionService
{
try
{
log.Information("[MSQProgression] ========================================");
log.Information("[MSQProgression] === DETECTING CURRENT EXPANSION ===");
log.Information("[MSQProgression] ========================================");
List<uint> completedQuests = questDetectionService.GetAllCompletedQuestIds();
log.Information($"[MSQProgression] Total completed quests: {completedQuests.Count}");
log.Information("[MSQProgression] METHOD 1: Using AgentScenarioTree (Game Data)");
log.Information("[MSQProgression] ------------------------------------------------");
(MSQExpansionData.Expansion expansion, string debugInfo) currentExpansionFromGameWithDebug = MSQExpansionData.GetCurrentExpansionFromGameWithDebug();
MSQExpansionData.Expansion gameExpansion = currentExpansionFromGameWithDebug.expansion;
string[] array = currentExpansionFromGameWithDebug.debugInfo.Split('\n');
foreach (string line in array)
for (int i = 0; i < array.Length; i++)
{
if (!string.IsNullOrWhiteSpace(line))
{
log.Information("[MSQProgression] " + line);
}
string.IsNullOrWhiteSpace(array[i]);
}
log.Information("[MSQProgression] Game Data Result: " + MSQExpansionData.GetExpansionName(gameExpansion));
log.Information("[MSQProgression] METHOD 2: Using Completed Quests Analysis");
log.Information("[MSQProgression] ------------------------------------------------");
MSQExpansionData.Expansion analysisExpansion = MSQExpansionData.GetCurrentExpansion(completedQuests);
log.Information("[MSQProgression] Analysis Result: " + MSQExpansionData.GetExpansionName(analysisExpansion));
array = MSQExpansionData.GetExpansionDetectionDebugInfo(completedQuests).Split('\n');
foreach (string line2 in array)
for (int i = 0; i < array.Length; i++)
{
if (!string.IsNullOrWhiteSpace(line2))
{
log.Debug("[MSQProgression] " + line2);
}
string.IsNullOrWhiteSpace(array[i]);
}
log.Information("[MSQProgression] COMPARISON:");
log.Information("[MSQProgression] Game Data: " + MSQExpansionData.GetExpansionName(gameExpansion));
log.Information("[MSQProgression] Analysis: " + MSQExpansionData.GetExpansionName(analysisExpansion));
MSQExpansionData.Expansion finalExpansion = gameExpansion;
if (gameExpansion == MSQExpansionData.Expansion.ARealmReborn && analysisExpansion != MSQExpansionData.Expansion.ARealmReborn)
{
log.Warning("[MSQProgression] Game data returned ARR but analysis found higher expansion!");
log.Warning("[MSQProgression] Using analysis result: " + MSQExpansionData.GetExpansionName(analysisExpansion));
finalExpansion = analysisExpansion;
}
log.Information("[MSQProgression] ========================================");
log.Information("[MSQProgression] >>> FINAL EXPANSION: " + MSQExpansionData.GetExpansionName(finalExpansion) + " <<<");
log.Information("[MSQProgression] ========================================");
return new ExpansionInfo
{
Name = MSQExpansionData.GetExpansionName(finalExpansion),
@ -416,10 +352,8 @@ public class MSQProgressionService
ExpectedQuestCount = MSQExpansionData.GetExpectedQuestCount(finalExpansion)
};
}
catch (Exception ex)
catch (Exception)
{
log.Error("[MSQProgression] Error detecting expansion: " + ex.Message);
log.Error("[MSQProgression] Stack: " + ex.StackTrace);
return GetExpansions().FirstOrDefault();
}
}
@ -514,28 +448,23 @@ public class MSQProgressionService
{
try
{
log.Information("[MSQProgression] === DEBUG CURRENT CHARACTER QUEST ===");
IPlayerCharacter player = clientState.LocalPlayer;
IPlayerCharacter player = objectTable.LocalPlayer;
if (player == null)
{
log.Warning("[MSQProgression] LocalPlayer is null - not logged in yet?");
framework.RunOnTick(delegate
{
DebugCurrentCharacterQuest();
}, default(TimeSpan), 60);
return;
}
string characterName = player.Name.TextValue;
string worldName = player.HomeWorld.Value.Name.ToString();
log.Information("[MSQProgression] Character: " + characterName + " @ " + worldName);
_ = player.Name.TextValue;
player.HomeWorld.Value.Name.ToString();
ExcelSheet<Quest> questSheet = dataManager.GetExcelSheet<Quest>();
if (questSheet == null)
{
log.Error("[MSQProgression] Failed to load Quest sheet!");
return;
}
List<Quest> completedMSQQuests = new List<Quest>();
log.Information("[MSQProgression] Checking MSQ quest completion...");
foreach (Quest quest in questSheet)
{
if (((ReadOnlySpan<uint>)MSQ_JOURNAL_GENRE_IDS).Contains(quest.JournalGenre.RowId) && QuestManager.IsQuestComplete((ushort)quest.RowId))
@ -543,60 +472,39 @@ public class MSQProgressionService
completedMSQQuests.Add(quest);
}
}
log.Information($"[MSQProgression] Character has {completedMSQQuests.Count} completed MSQ quests");
if (completedMSQQuests.Count == 0)
{
log.Warning("[MSQProgression] No completed MSQ quests found!");
return;
}
Quest latestMSQQuest = completedMSQQuests.OrderByDescending((Quest quest2) => quest2.RowId).First();
log.Information($"[MSQProgression] Latest completed MSQ quest ID: {latestMSQQuest.RowId}");
Quest questData = latestMSQQuest;
log.Information("[MSQProgression] === LATEST MSQ QUEST DETAILS ===");
log.Information($"[MSQProgression] Quest ID: {questData.RowId}");
log.Information($"[MSQProgression] Quest Name: {questData.Name}");
log.Information($"[MSQProgression] JournalGenre.RowId: {questData.JournalGenre.RowId}");
Quest questData = completedMSQQuests.OrderByDescending((Quest q) => q.RowId).First();
try
{
string genreName = questData.JournalGenre.Value.Name.ToString();
log.Information("[MSQProgression] JournalGenre.Name: " + genreName);
questData.JournalGenre.Value.Name.ToString();
}
catch
{
log.Information("[MSQProgression] JournalGenre.Name: ERROR");
}
log.Information($"[MSQProgression] Expansion.RowId: {questData.Expansion.RowId}");
try
{
string expansionName = questData.Expansion.Value.Name.ToString();
log.Information("[MSQProgression] Expansion.Name: " + expansionName);
questData.Expansion.Value.Name.ToString();
}
catch
{
log.Information("[MSQProgression] Expansion.Name: ERROR");
}
log.Information("[MSQProgression] === CHARACTER IS IN THIS EXPANSION ===");
log.Information($"[MSQProgression] Character is at Quest {questData.RowId} which is in:");
log.Information($"[MSQProgression] - JournalGenre: {questData.JournalGenre.RowId}");
log.Information($"[MSQProgression] - Expansion: {questData.Expansion.RowId}");
log.Information("[MSQProgression] === RECENT COMPLETED MSQ QUESTS (Last 10) ===");
foreach (Quest q in completedMSQQuests.OrderByDescending((Quest quest2) => quest2.RowId).Take(10).ToList())
foreach (Quest item in completedMSQQuests.OrderByDescending((Quest q) => q.RowId).Take(10).ToList())
{
log.Information($"[MSQProgression] Quest {q.RowId}: {q.Name} (Genre: {q.JournalGenre.RowId}, Exp: {q.Expansion.RowId})");
_ = item;
}
log.Information("[MSQProgression] === COMPLETED MSQ QUESTS BY EXPANSION ===");
foreach (IGrouping<MSQExpansionData.Expansion, Quest> group in from quest2 in completedMSQQuests
group quest2 by JournalGenreToExpansion.GetValueOrDefault(quest2.JournalGenre.RowId, MSQExpansionData.Expansion.ARealmReborn) into g
foreach (IGrouping<MSQExpansionData.Expansion, Quest> item2 in from q in completedMSQQuests
group q by JournalGenreToExpansion.GetValueOrDefault(q.JournalGenre.RowId, MSQExpansionData.Expansion.ARealmReborn) into g
orderby g.Key
select g)
{
log.Information($"[MSQProgression] {group.Key}: {group.Count()} quests completed");
_ = item2;
}
}
catch (Exception ex)
catch (Exception)
{
log.Error("[MSQProgression] ERROR in DebugCurrentCharacterQuest: " + ex.Message);
log.Error("[MSQProgression] Stack trace: " + ex.StackTrace);
}
}
}