Add modules to items, upgrades the can persist through combinations

src/Dodge/Combine.hs

@@ -3,6 +3,7 @@ module Dodge.Combine
     ( combinePoss
     , combineSizes
     , combineItemListYou
+    , combineItemListYou'
     , toggleCombineInv
     , enterCombineInv
     ) where
@@ -10,6 +11,7 @@ import Dodge.Combine.Combinations
 import Dodge.Base.You
 import Dodge.Data
 import Dodge.Item.Amount
+import Dodge.Inventory.ItemSpace
 --import Dodge.Combine.Data
 import Multiset
 import SimpleTrie
@@ -32,29 +34,52 @@ combinationsTrie = foldr
 -- trie going through each combine type in your inventory in order, rather than
 -- creating all multisets of combine types.
 
-lookupItems :: [(CombineType,Int,Int)] -> [ ([Int],Item) ]
-lookupItems xs = lookupItemsUsingTrie (sortOn (\(ct,_,_) -> ct) xs) combinationsTrie
+lookupItems :: [(ItemModules,CombineType,Int,Int)] -> [ ([(ItemModules,Int)],Item) ]
+lookupItems xs = lookupItemsUsingTrie (sortOn (\(_,ct,_,_) -> ct) xs) combinationsTrie
 
-lookupItemsUsingTrie :: [(CombineType,Int,Int)] -> Trie (Int,CombineType) Item -> [ ([Int],Item) ]
+lookupItemsUsingTrie :: [(ItemModules,CombineType,Int,Int)] 
+    -> Trie (Int,CombineType) Item -> [ ([(ItemModules,Int)],Item) ]
 lookupItemsUsingTrie [] t = maybeToList $ ([],) <$> _trieMVal t
-lookupItemsUsingTrie ((ct,i,n):xs) t = do
+lookupItemsUsingTrie ((mods,ct,i,n):xs) t = do
     n' <- [1..min n 4]
-    let is = replicate n' i
+    let is = replicate n' (mods,i)
     concatMap (map (first (is ++)) . lookupItemsUsingTrie xs) $ maybeToList (_trieChildren t M.!? (n',ct))
 
-invertListInvMult :: IM.IntMap Item -> [[(CombineType,Int,Int)]]
+invertListInvMult :: IM.IntMap Item -> [[(ItemModules,CombineType,Int,Int)]]
 invertListInvMult = powlistUpToN 4 . invertListInv
 
-invertListInv :: IM.IntMap Item -> [(CombineType,Int,Int)]
+invertListInv :: IM.IntMap Item -> [(ItemModules,CombineType,Int,Int)]
 invertListInv = IM.foldrWithKey
-    (\k it -> ((_itType it, k, itStackAmount it) :) )
+    (\k it -> ((_itModules it,_itType it, k, itStackAmount it) :) )
     []
 
 -- gives a list of indices-item pairs.
 -- Note that within the pair, indices can be repeated if two or more of an item
 -- are needed
 combineItemListYou :: World -> [([Int],Item)]
-combineItemListYou = concatMap lookupItems . invertListInvMult . yourInv
+combineItemListYou = map (second fst) . combineItemListYou'
+
+combineItemListYou' :: World -> [([Int],(Item,[String]))]
+combineItemListYou' = concatMap addModules . concatMap lookupItems . invertListInvMult . yourInv
+
+addModules :: ([(ItemModules,Int)],Item) -> [([Int],(Item,[String]))]
+addModules (ps,it) = (is , ) <$> [ (it & itModules .~ themodules,s) | (themodules,s) <- combinedmodules]
+  where
+    (ms,is) = unzip ps
+    combinedmodules = foldr f [(_itModules it,[])] ms
+    f ims imss = concatMap (g ims) imss
+    g ims (ims',s) = map (second (s++)) $ combineModules ims ims'
+
+combineModules :: ItemModules -> ItemModules -> [(ItemModules,[String])]
+combineModules (ItemModules a1) (ItemModules a2)
+    = [(ItemModules a,ss) | (a,ss) <- combineModule a1 a2]
+
+combineModule :: ItemModule a -> ItemModule a -> [(ItemModule a,[String])]
+combineModule BlockedModule (ItemModule _ ss _) = [(BlockedModule, "WARNING:REMOVES":ss)]
+combineModule BlockedModule _ = [(BlockedModule,["a"])]
+combineModule m BlockedModule = [(m,[])]
+combineModule DefaultModule m = [(m,[])]
+combineModule m _ = [(m,[])]
 
 toggleCombineInv :: World -> World
 toggleCombineInv w = case _inventoryMode w of
@@ -67,7 +92,8 @@ enterCombineInv w = w & inventoryMode .~ CombineInventory mi
     mi = 0 <$ listToMaybe (combineItemListYou w)
 
 combineSizes :: World -> [Int]
-combineSizes = map (ceiling . _itInvSize . snd) . combineItemListYou
+--combineSizes = map (ceiling . _itInvSize . snd) . combineItemListYou
+combineSizes = map (itSlotsTaken . snd) . combineItemListYou
 
 combinePoss :: World -> [Int]
 combinePoss = scanl' (+) 0 . combineSizes