Add pet enhancer upgrade planning

app.py

@@ -2123,6 +2123,9 @@ class UpgradeLabInput(BaseModel):
     strategy: str = "auto"
     elf_route: Optional[str] = None
     elf_level5_count: int = 0
+    player_level: Optional[int] = None
+    pet_use_gold: bool = False
+    pet_helper_odds: bool = False
 
 
 # ─────────────────────────────────────────────────────────────────
@@ -2874,6 +2877,94 @@ def _elf_result_distribution(level5_dist: dict, success_chance=0.8):
                     result[successes] = result.get(successes, 0.0) + level5_prob * prob
     return dict(sorted(result.items()))
 
+_PET_ENHANCER_ROUTES = [
+    {"source": "Peppy", "result": "XPeppy"},
+    {"source": "Blue Axolotl", "result": "XAxolotl"},
+    {"source": "Pengoo", "result": "XPengoo"},
+    {"source": "Leo", "result": "XLeo"},
+    {"source": "Phoenix", "result": "XPhoenix"},
+    {"source": "Octoo", "result": "XOctoo"},
+    {"source": "Xen", "result": "XXen"},
+    {"source": "Inferno", "result": "XInferno"},
+]
+
+_PET_ENHANCER_CHANCES = [
+    {"min": 0, "max": 2000, "free": [1.0, 0.5, 0.33, 0.25, 0.20, 0.17, 0.14, 0.13], "gold": [3.0, 1.5, 1.0, 0.75, 0.60, 0.50, 0.43, 0.38]},
+    {"min": 2001, "max": 3000, "free": [3.0, 1.5, 1.0, 0.75, 0.60, 0.50, 0.43, 0.38], "gold": [9.0, 4.5, 3.0, 2.25, 1.80, 1.50, 1.29, 1.13]},
+    {"min": 3001, "max": 4000, "free": [5.0, 2.5, 1.67, 1.25, 1.0, 0.83, 0.71, 0.63], "gold": [15.0, 7.5, 5.0, 3.75, 3.0, 2.50, 2.14, 1.88]},
+    {"min": 4001, "max": 5000, "free": [7.0, 3.5, 2.33, 1.75, 1.40, 1.17, 1.0, 0.88], "gold": [21.0, 10.5, 7.0, 5.25, 4.20, 3.50, 3.0, 2.63]},
+    {"min": 5001, "max": 6000, "free": [10.0, 5.0, 3.33, 2.50, 2.0, 1.67, 1.43, 1.25], "gold": [30.0, 15.0, 10.0, 7.50, 6.0, 5.0, 4.29, 3.75]},
+    {"min": 6001, "max": 7000, "free": [15.0, 7.5, 5.0, 3.75, 3.0, 2.50, 2.14, 1.88], "gold": [45.0, 22.5, 15.0, 11.25, 9.0, 7.50, 6.43, 5.63]},
+    {"min": 7001, "max": 8000, "free": [20.0, 10.0, 6.67, 5.0, 4.0, 3.33, 2.86, 2.50], "gold": [60.0, 30.0, 20.0, 15.0, 12.0, 10.0, 8.57, 7.50]},
+    {"min": 8001, "max": 9000, "free": [25.0, 12.5, 8.33, 6.25, 5.0, 4.17, 3.57, 3.13], "gold": [75.0, 37.5, 25.0, 18.75, 15.0, 12.50, 10.71, 9.38]},
+    {"min": 9001, "max": 10000, "free": [30.0, 15.0, 10.0, 7.50, 6.0, 5.0, 4.29, 3.75], "gold": [90.0, 45.0, 30.0, 22.50, 18.0, 15.0, 12.86, 11.25]},
+    {"min": 10001, "max": None, "free": [33.0, 16.5, 11.0, 8.25, 6.60, 5.50, 4.71, 4.13], "gold": [99.0, 49.5, 33.0, 24.75, 19.80, 16.50, 14.14, 12.38]},
+]
+
+def _pet_enhancer_routes():
+    routes = []
+    for index, route in enumerate(_PET_ENHANCER_ROUTES):
+        source = route["source"]
+        result = route["result"]
+        if source not in PETS or result not in PETS:
+            continue
+        routes.append({
+            "key": f"pet|{source}|{result}",
+            "item_type": "pet",
+            "source": source,
+            "result": result,
+            "index": index,
+        })
+    return routes
+
+def _pet_enhancer_route_for_name(name: str):
+    clean = str(name or "").strip().lower()
+    for route in _pet_enhancer_routes():
+        if route["source"].lower() == clean or route["result"].lower() == clean:
+            return route
+    return None
+
+def _pet_enhancer_tier(player_level: int, helper_odds: bool = False):
+    if helper_odds:
+        return _PET_ENHANCER_CHANCES[-1]
+    try:
+        level = max(0, int(player_level or 0))
+    except (TypeError, ValueError):
+        level = 0
+    for row in _PET_ENHANCER_CHANCES:
+        if level >= row["min"] and (row["max"] is None or level <= row["max"]):
+            return row
+    return _PET_ENHANCER_CHANCES[-1]
+
+def _pet_enhancer_chance(route: dict, player_level: int, use_gold: bool, helper_odds: bool):
+    tier = _pet_enhancer_tier(player_level, helper_odds)
+    key = "gold" if use_gold else "free"
+    index = int(route.get("index", 0) or 0)
+    chance_pct = float(tier[key][index])
+    return max(0.0, min(1.0, chance_pct / 100.0)), chance_pct, tier
+
+def _binomial_distribution(n: int, p: float):
+    n = max(0, int(n or 0))
+    p = max(0.0, min(1.0, float(p or 0.0)))
+    if n <= 0:
+        return {0: 1.0}
+    if p <= 0.0:
+        return {0: 1.0}
+    if p >= 1.0:
+        return {n: 1.0}
+    dist = {}
+    for successes in range(n + 1):
+        prob = math.exp(
+            math.lgamma(n + 1)
+            - math.lgamma(successes + 1)
+            - math.lgamma(n - successes + 1)
+            + successes * math.log(p)
+            + (n - successes) * math.log1p(-p)
+        )
+        if prob > 1e-15:
+            dist[successes] = prob
+    return dist
+
 _KNOWN_ELF_ROUTES = {
     ("sword", "Dragon's Poison"): "Dragon's Devil",
     ("shield", "Dragon's Anger"): "Dragon's Soul",
@@ -2955,6 +3046,15 @@ def _upgrade_lab_meta():
                 "world": item.get("world", ""),
                 "source": item.get("source", ""),
             })
+    for route in _pet_enhancer_routes():
+        items.append({
+            "name": route["source"],
+            "item_type": "pet",
+            "rarity": "Pet",
+            "world": "Enhancer",
+            "source": "Pet Enhancer",
+            "enhances_to": route["result"],
+        })
     return {
         "items": items,
         "swords": [
@@ -2965,6 +3065,8 @@ def _upgrade_lab_meta():
             {"name": item.get("name"), "rarity": item.get("rarity"), "world": item.get("world", "")}
             for item in (_GAME_CATALOG.get("shields") or [])
         ],
+        "pet_routes": _pet_enhancer_routes(),
+        "pet_chance_tiers": _PET_ENHANCER_CHANCES,
         "elf_routes": _elf_routes(),
         "dwarf_luck": {
             rarity: [
@@ -2980,13 +3082,90 @@ def _upgrade_lab_meta():
         },
     }
 
+def _upgrade_lab_pet_calculate(data: UpgradeLabInput):
+    item_name = str(data.item_name or "").strip()
+    route = _pet_enhancer_route_for_name(item_name)
+    if not route:
+        raise HTTPException(400, f"{item_name!r} has no known Pet Enhancer route.")
+    target_count = max(1, int(data.target_count or 1))
+    counts = data.counts or {}
+    normal_count = max(0, int(counts.get("pet", counts.get("1", counts.get(1, 0))) or 0))
+    attempts = normal_count // 10
+    leftovers = normal_count % 10
+    player_level = 10001 if data.pet_helper_odds else max(0, int(data.player_level or 0))
+    chance, chance_pct, tier = _pet_enhancer_chance(route, player_level, data.pet_use_gold, data.pet_helper_odds)
+    result_dist = _binomial_distribution(attempts, chance)
+    probability = _distribution_tail(result_dist, target_count)
+    expected = attempts * chance
+    gold_cost = attempts * 1e15 if data.pet_use_gold else 0.0
+    return {
+        "ok": True,
+        "item": {
+            "type": "pet",
+            "name": route["source"],
+            "rarity": "Pet",
+            "world": "Enhancer",
+            "source": "Pet Enhancer",
+        },
+        "prices": {},
+        "goal": {
+            "kind": "pet",
+            "label": route["result"],
+            "target_count": target_count,
+            "source_name": route["source"],
+            "result_name": route["result"],
+        },
+        "plan": {
+            "strategy": "pet_enhancer",
+            "probability": probability,
+            "probability_pct": probability * 100.0,
+            "expected_count": expected,
+            "distribution": _distribution_rows(result_dist),
+            "steps": [{
+                "from_level": 0,
+                "to_level": 0,
+                "action": "enhance",
+                "chance": chance,
+                "chance_pct": chance_pct,
+                "expected_input": float(normal_count),
+                "expected_output": expected,
+                "merge_required": 10,
+                "from_label": f"10x {route['source']}",
+                "to_label": route["result"],
+                "attempts": attempts,
+                "leftovers": leftovers,
+                "gold_cost": gold_cost,
+                "gold_cost_display": _price_fmt(gold_cost) if gold_cost else "0",
+            }],
+        },
+        "valuation": {
+            "gold_cost": gold_cost,
+            "gold_cost_display": _price_fmt(gold_cost) if gold_cost else "0",
+        },
+        "pet": {
+            "route": route,
+            "source_count": normal_count,
+            "attempts": attempts,
+            "leftovers": leftovers,
+            "player_level": player_level,
+            "helper_odds": bool(data.pet_helper_odds),
+            "use_gold": bool(data.pet_use_gold),
+            "chance": chance,
+            "chance_pct": chance_pct,
+            "tier": tier,
+        },
+        "elf": {"eligible": False, "routes": _elf_routes(), "route": None},
+    }
+
 def _upgrade_lab_calculate(data: UpgradeLabInput):
     item_name = str(data.item_name or "").strip()
+    target_kind = str(data.target_kind or "level").strip().lower()
+    if target_kind in ("pet", "xpet", "pet_enhancer", "enhancer"):
+        return _upgrade_lab_pet_calculate(data)
     singular, category, item = _upgrade_item_lookup(item_name, data.item_type)
     rarity = str(item.get("rarity") or "Common")
     target_level = max(1, min(10, int(data.target_level or 1)))
     target_count = max(1, int(data.target_count or 1))
-    target_kind = str(data.target_kind or "level").strip().lower()
     strategy = str(data.strategy or "auto").strip().lower()
     if strategy not in ("auto", "dwarf", "dwarft", "dwarfting", "merge", "merging"):
         strategy = "auto"

static/index.html

@@ -716,13 +716,26 @@ input::placeholder{color:var(--text3);}
               <select id="up-target-kind" onchange="upgradeGoalChanged()">
                 <option value="level">Item Level</option>
                 <option value="elf">Elf Legendary</option>
+                <option value="pet">Pet Enhancer</option>
               </select>
             </div>
             <div id="up-target-level-wrap"><label>Target Level</label><input id="up-target-level" type="number" value="5" min="1" max="10"></div>
             <div><label>Target Count</label><input id="up-target-count" type="number" value="1" min="1"></div>
           </div>
+          <div id="up-pet-controls" class="fr c3" style="display:none;margin-top:7px">
+            <div><label>Player Level</label><input id="up-player-level" type="number" value="10000" min="0"></div>
+            <div><label>Odds</label>
+              <select id="up-pet-cost">
+                <option value="free">Free</option>
+                <option value="gold">With 1QT Gold</option>
+              </select>
+            </div>
+            <label style="display:flex;align-items:center;gap:6px;margin-top:17px;color:var(--text2);font-family:'Rajdhani',sans-serif;font-size:11px;letter-spacing:1px">
+              <input id="up-helper-odds" type="checkbox" style="width:auto"> 10K+ HELPER ODDS
+            </label>
+          </div>
           <div id="up-elf-hint" class="upgrade-mini" style="display:none;margin-top:6px"></div>
-          <div class="stitle">Items Owned By Level</div>
+          <div class="stitle" id="up-count-title">Items Owned By Level</div>
           <div id="up-count-grid" class="upgrade-count-grid"></div>
           <button class="btn btn-p" style="width:100%;justify-content:center;margin-top:12px;padding:9px" onclick="upgradeCalc()">CALCULATE</button>
           <div id="up-status" class="upgrade-mini" style="margin-top:9px;min-height:14px">Choose an item, enter counts, or import an account.</div>
@@ -1626,26 +1639,59 @@ function _upgradeRouteForItem(name){
   return (UPGRADE_META?.elf_routes||[]).find(row=>String(row.source||'').toLowerCase()===clean)||null;
 }
 
+function _upgradePetRouteForItem(name){
+  const clean=String(name||'').trim().toLowerCase();
+  return (UPGRADE_META?.pet_routes||[]).find(row=>
+    String(row.source||'').toLowerCase()===clean || String(row.result||'').toLowerCase()===clean
+  )||null;
+}
+
 function upgradeItemChanged(syncRoute=true){
   const name=document.getElementById('up-item-name')?.value||'';
   const route=_upgradeRouteForItem(name);
+  const petRoute=_upgradePetRouteForItem(name);
   const goal=document.getElementById('up-target-kind');
   if(goal&&goal.value==='elf'&&!route)goal.value='level';
+  if(goal&&goal.value==='pet'&&!petRoute)goal.value='level';
+  if(goal&&goal.value==='level'&&petRoute)goal.value='pet';
   upgradeGoalChanged();
 }
 
 function upgradeGoalChanged(){
   const goal=document.getElementById('up-target-kind');
-  const route=_upgradeRouteForItem(document.getElementById('up-item-name')?.value||'');
+  const itemName=document.getElementById('up-item-name')?.value||'';
+  const route=_upgradeRouteForItem(itemName);
+  const petRoute=_upgradePetRouteForItem(itemName);
   const elfOption=goal?.querySelector('option[value="elf"]');
   if(elfOption)elfOption.disabled=!route;
+  const petOption=goal?.querySelector('option[value="pet"]');
+  if(petOption)petOption.disabled=!petRoute;
   if(goal&&goal.value==='elf'&&!route)goal.value='level';
+  if(goal&&goal.value==='pet'&&!petRoute)goal.value='level';
+  if(goal&&goal.value==='level'&&petRoute)goal.value='pet';
   const kind=goal?.value||'level';
   const wrap=document.getElementById('up-target-level-wrap');
-  if(wrap)wrap.style.display=kind==='elf'?'none':'';
+  if(wrap)wrap.style.display=(kind==='elf'||kind==='pet')?'none':'';
+  const petControls=document.getElementById('up-pet-controls');
+  if(petControls)petControls.style.display=kind==='pet'?'grid':'none';
+  const countTitle=document.getElementById('up-count-title');
+  if(countTitle)countTitle.textContent=kind==='pet'?'Normal Pets Owned':'Items Owned By Level';
+  document.querySelectorAll('#up-count-grid>div').forEach((cell,index)=>{
+    const label=cell.querySelector('label');
+    if(kind==='pet'){
+      cell.style.display=index===0?'':'none';
+      if(label)label.textContent=petRoute?petRoute.source:'Normal Pet';
+    }else{
+      cell.style.display='';
+      if(label)label.textContent=`Lv${index+1}`;
+    }
+  });
   const hint=document.getElementById('up-elf-hint');
   if(hint){
-    if(kind==='elf'&&route){
+    if(kind==='pet'&&petRoute){
+      hint.style.display='';
+      hint.textContent=`Pet Enhancer: 10x ${petRoute.source} -> ${petRoute.result}. Failed attempts consume the 10 pets too.`;
+    }else if(kind==='elf'&&route){
       hint.style.display='';
       hint.textContent=`Elf: 10x ${route.source} Lv5 -> ${route.result}. Success chance is 80%; success and fail both consume the 10 Epics.`;
     }else if(route){
@@ -1677,6 +1723,13 @@ function _upgradeLoadedCountsFor(name){
   const clean=String(name||'').trim().toLowerCase();
   const counts={};
   for(let level=1;level<=10;level++)counts[String(level)]=0;
+  const petRoute=_upgradePetRouteForItem(name);
+  if(petRoute){
+    counts['1']=(UPGRADE_LOADED_ITEMS||[]).filter(row=>
+      row.item_type==='pet' && String(row.name||'').trim().toLowerCase()===String(petRoute.source||'').toLowerCase()
+    ).length;
+    return counts;
+  }
   for(const row of UPGRADE_LOADED_ITEMS||[]){
     if(String(row.name||'').trim().toLowerCase()!==clean)continue;
     const level=Math.max(1,Math.min(10,parseInt(row.level,10)||1));
@@ -1729,8 +1782,12 @@ async function upgradeLoadAccount(){
     const d=bulk.results?.[name]||Object.values(bulk.results||{})[0];
     if(!d||!d.ok)throw new Error(d?.error||'No live lookup result.');
     const inv=d.inventory||{};
-    UPGRADE_LOADED_ITEMS=[...(inv.swords||[]),...(inv.shields||[])].filter(row=>row&&row.name);
-    if(!UPGRADE_LOADED_ITEMS.length)throw new Error('No swords or shields found in this live inventory.');
+    UPGRADE_LOADED_ITEMS=[
+      ...(inv.swords||[]).map(row=>({...row,item_type:'sword'})),
+      ...(inv.shields||[]).map(row=>({...row,item_type:'shield'})),
+      ...(inv.pets||[]).map(row=>({...row,item_type:'pet'})),
+    ].filter(row=>row&&row.name);
+    if(!UPGRADE_LOADED_ITEMS.length)throw new Error('No swords, shields or pets found in this live inventory.');
     const input=document.getElementById('up-item-name');
     if(input&&!input.value.trim()){
       const best=_upgradeBestLoadedItem();
@@ -1743,8 +1800,8 @@ async function upgradeLoadAccount(){
     if(status){
       status.style.color=total>0?'var(--green)':'var(--gold)';
       status.textContent=total>0
-        ? `Loaded ${UPGRADE_LOADED_ITEMS.length} swords/shields from ${d.username||name}. Showing ${total}x ${input?.value||'selected item'}.`
-        : `Loaded ${UPGRADE_LOADED_ITEMS.length} swords/shields from ${d.username||name}. No ${input?.value||'selected item'} found.`;
+        ? `Loaded ${UPGRADE_LOADED_ITEMS.length} items from ${d.username||name}. Showing ${total}x ${input?.value||'selected item'}.`
+        : `Loaded ${UPGRADE_LOADED_ITEMS.length} items from ${d.username||name}. No ${input?.value||'selected item'} found.`;
     }
   }catch(e){
     if(status){status.style.color='var(--red)';status.textContent=`Import failed: ${e.message}`;}
@@ -1798,7 +1855,10 @@ async function upgradeCalc(){
   const itemName=document.getElementById('up-item-name')?.value||'';
   const meta=_upgradeItemMeta(itemName);
   const route=_upgradeRouteForItem(itemName);
-  const kind=document.getElementById('up-target-kind')?.value||'level';
+  const petRoute=_upgradePetRouteForItem(itemName);
+  let kind=document.getElementById('up-target-kind')?.value||'level';
+  if(petRoute&&kind==='level')kind='pet';
+  if(kind==='pet'&&!petRoute)kind='level';
   const payload={
     item_type:meta?.item_type||'',
     item_name:itemName,
@@ -1808,6 +1868,9 @@ async function upgradeCalc(){
     target_level:parseInt(document.getElementById('up-target-level')?.value,10)||1,
     target_count:parseInt(document.getElementById('up-target-count')?.value,10)||1,
     elf_route:kind==='elf'&&route?route.key:null,
+    player_level:parseInt(document.getElementById('up-player-level')?.value,10)||0,
+    pet_use_gold:document.getElementById('up-pet-cost')?.value==='gold',
+    pet_helper_odds:!!document.getElementById('up-helper-odds')?.checked,
   };
   try{
     const data=await post('/upgrade-lab',payload);
@@ -1835,12 +1898,14 @@ function renderUpgradeResult(data){
       ? `${row.merge_required}x required`
       : row.action==='merge+dwarf'
         ? `${row.merge_required}x merge, leftovers dwarf ${Number(row.dwarf_chance_pct||0).toFixed(2)}%`
+      : row.action==='enhance'
+        ? `${row.merge_required}x per try, ${Number(row.chance_pct||0).toFixed(2)}%${row.gold_cost?`, gold ${row.gold_cost_display}`:''}`
       : row.action==='elf'
         ? '10x Lv5, 80%, fail destroys inputs'
         : `${Number(row.chance_pct||0).toFixed(2)}% success`;
     return `<tr>
       <td>${_escHtml(from)} -> ${_escHtml(to)}</td>
-      <td style="color:${row.action==='merge'?'var(--green)':row.action==='merge+dwarf'?'var(--gold)':row.action==='elf'?'var(--gold)':'var(--accent)'}">${_escHtml(action)}</td>
+      <td style="color:${row.action==='merge'?'var(--green)':row.action==='merge+dwarf'?'var(--gold)':row.action==='elf'||row.action==='enhance'?'var(--gold)':'var(--accent)'}">${_escHtml(action)}</td>
       <td>${_escHtml(rule)}</td>
       <td>${_numText(row.expected_input,3)}</td>
       <td>${_numText(row.expected_output,3)}</td>

tests/test_market_optimizer_logic.py

@@ -994,11 +994,40 @@ class MarketOptimizerLogicTests(unittest.TestCase):
         self.assertAlmostEqual(distribution[1], 0.8)
         self.assertAlmostEqual(result["plan"]["expected_count"], 0.8)
 
+    def test_pet_enhancer_uses_level_gold_chance_table(self):
+        result = self.app._upgrade_lab_calculate(self.app.UpgradeLabInput(
+            item_name="Inferno",
+            counts={"1": 20},
+            target_kind="pet",
+            target_count=1,
+            player_level=10001,
+            pet_use_gold=True,
+        ))
+        chance = 0.1238
+        self.assertEqual(result["goal"]["result_name"], "XInferno")
+        self.assertEqual(result["pet"]["attempts"], 2)
+        self.assertAlmostEqual(result["pet"]["chance"], chance)
+        self.assertAlmostEqual(result["plan"]["expected_count"], 2 * chance)
+        self.assertAlmostEqual(result["plan"]["probability"], 1 - (1 - chance) ** 2)
+
+    def test_pet_enhancer_accepts_result_name_as_lookup_alias(self):
+        result = self.app._upgrade_lab_calculate(self.app.UpgradeLabInput(
+            item_name="XInferno",
+            counts={"1": 10},
+            target_kind="pet",
+            target_count=1,
+            pet_helper_odds=True,
+        ))
+        self.assertEqual(result["item"]["name"], "Inferno")
+        self.assertEqual(result["goal"]["label"], "XInferno")
+        self.assertEqual(result["pet"]["source_count"], 10)
+
     def test_frontend_flame_solver_uses_explicit_solved_flag(self):
         html = (Path(__file__).resolve().parents[1] / "static" / "index.html").read_text(encoding="utf-8")
         self.assertIn("let solved=false;", html)
         self.assertIn("solved=true;break;", html)
         self.assertNotIn("if(ticks===0){", html)
+        self.assertIn('<option value="pet">Pet Enhancer</option>', html)
 
     def test_market_selection_keeps_current_setup_as_search_seed(self):
         accounts = [self.account("A"), self.account("B")]