From a6cb937485f4b62123de46b2bc48ff34d42a901f Mon Sep 17 00:00:00 2001
From: Daan Vanden Bosch <daan.v.d.bosch@gmail.com>
Date: Sat, 15 Jun 2019 23:00:46 +0200
Subject: [PATCH] All valid section IDs are now shown in the hunt optimization
 results instead of just one random one.

---
 src/stores/HuntOptimizerStore.ts              | 62 +++++++++++++++----
 .../OptimizationResultComponent.tsx           |  3 +-
 2 files changed, 52 insertions(+), 13 deletions(-)

diff --git a/src/stores/HuntOptimizerStore.ts b/src/stores/HuntOptimizerStore.ts
index 8b12f076..8a257942 100644
--- a/src/stores/HuntOptimizerStore.ts
+++ b/src/stores/HuntOptimizerStore.ts
@@ -21,7 +21,7 @@ export class OptimizationResult {
 
     constructor(
         public readonly difficulty: Difficulty,
-        public readonly sectionId: SectionId,
+        public readonly sectionIds: Array<SectionId>,
         public readonly methodName: string,
         public readonly methodTime: number,
         public readonly runs: number,
@@ -33,8 +33,8 @@ export class OptimizationResult {
 
 // TODO: Prefer methods that don't split pan arms over methods that do.
 //       For some reason this doesn't actually seem to be a problem, should probably investigate.
-// TODO: group similar methods (e.g. same difficulty, same quest and similar ID).
-//       This way people can choose their preferred section ID.
+// TODO: Show expected value or probability per item per method.
+//       Can be useful when you want one item "more" than the others.
 // TODO: order of items in results table should match order in wanted table.
 // TODO: boxes.
 class HuntOptimizerStore {
@@ -200,12 +200,9 @@ class HuntOptimizerStore {
                         }
 
                         if (addVariable) {
-                            let name = `${diff}\t${sectionId}\t${method.name}`;
-
-                            if (splitPanArms) {
-                                name += ' (Split Pan Arms)';
-                            }
-
+                            const name = this.fullMethodName(
+                                diff, sectionId, method, splitPanArms
+                            );
                             variables[name] = variable;
                             variableDetails.set(name, {
                                 method,
@@ -248,18 +245,48 @@ class HuntOptimizerStore {
 
                     const items = new Map<Item, number>();
 
-                    for (const [itemName, expectedValue] of Object.entries(variable)) {
+                    for (const [itemName, expectedAmount] of Object.entries(variable)) {
                         for (const item of wantedItems) {
                             if (itemName === item.name) {
-                                items.set(item, runs * expectedValue);
+                                items.set(item, runs * expectedAmount);
                                 break;
                             }
                         }
                     }
 
+                    // Find all section IDs that provide the same items with the same expected amount.
+                    // E.g. if you need a spread needle and a bringer's right arm, using either
+                    // purplenum or yellowboze will give you the exact same probabilities.
+                    const sectionIds: Array<SectionId> = [];
+
+                    for (const sid of SectionIds) {
+                        let matchFound = true;
+
+                        if (sid !== sectionId) {
+                            const v = variables[
+                                this.fullMethodName(difficulty, sid, method, splitPanArms)
+                            ];
+
+                            if (!v) {
+                                matchFound = false;
+                            } else {
+                                for (const itemName of Object.keys(variable)) {
+                                    if (variable[itemName] !== v[itemName]) {
+                                        matchFound = false;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+
+                        if (matchFound) {
+                            sectionIds.push(sid);
+                        }
+                    }
+
                     this.results.push(new OptimizationResult(
                         difficulty,
-                        sectionId,
+                        sectionIds,
                         method.name + (splitPanArms ? ' (Split Pan Arms)' : ''),
                         method.time,
                         runs,
@@ -269,6 +296,17 @@ class HuntOptimizerStore {
             }
         });
     }
+
+    private fullMethodName(
+        difficulty: Difficulty,
+        sectionId: SectionId,
+        method: HuntMethod,
+        splitPanArms: boolean
+    ): string {
+        let name = `${difficulty}\t${sectionId}\t${method.name}`;
+        if (splitPanArms) name += ' (Split Pan Arms)';
+        return name;
+    }
 }
 
 export const huntOptimizerStore = new HuntOptimizerStore();
diff --git a/src/ui/hunt-optimizer/OptimizationResultComponent.tsx b/src/ui/hunt-optimizer/OptimizationResultComponent.tsx
index 1b4cc96a..f7b45ddb 100644
--- a/src/ui/hunt-optimizer/OptimizationResultComponent.tsx
+++ b/src/ui/hunt-optimizer/OptimizationResultComponent.tsx
@@ -37,7 +37,8 @@ export class OptimizationResultComponent extends React.Component {
             {
                 name: 'Section ID',
                 width: 80,
-                cellRenderer: (result) => result.sectionId,
+                cellRenderer: (result) => result.sectionIds.join(', '),
+                tooltip: (result) => result.sectionIds.join(', '),
             },
             {
                 name: 'Time/Run',