Pokemon optimizer enhancements

configs/config.json.optimizer.example

@@ -21,25 +21,74 @@
         {
             "type": "PokemonOptimizer",
             "config": {
+                    "// the 'transfer' parameter activate or deactivate the transfer of pokemons": {},
+                    "// at false, no pokemon is going to be transfered, ever": {},
+                    "// at false, you will still get the log information of what the optimizer": {},
+                    "// would have transfered if the parameter was true": {},
                 "transfer": true,
+                    "// the 'evolve' parameter activate or deactivate the evolution of pokemons": {},
+                    "// at false, no pokemon is going to be evolved, ever": {},
+                    "// at false, you will still get the log information of what the": {},
+                    "// optimizer would have evolved if the parameter was true": {},
                 "evolve": true,
+                    "// the 'use_candies_for_xp' parameter let you choose if you want the optimizer": {},
+                    "// to use your candies to evolve low quality pokemons in order to maximize your xp": {},
+                    "// at false, the optimizer will still use candies to evolve your best Pokemons": {},
+                "use_candies_for_xp": true,
+                    "// the 'use_lucky_egg' parameter let you choose if you want the optimizer": {},
+                    "// to use a lucky egg right before evolving Pokemons. At false; the optimizer": {},
+                    "// is free to evolve Pokemons even if you do not have any lucky egg.": {},
                 "use_lucky_egg": true,
+                    "// the 'evolve_only_with_lucky_egg' parameter let you choose if you want the optimizer": {},
+                    "// to only Evolve Pokemons when a lucky egg is available": {},
                 "evolve_only_with_lucky_egg": true,
+                    "// the 'minimum_evolve_for_lucky_egg' parameter let you define the minimum": {},
+                    "// number of Pokemons that must evolve before using a lucky egg": {},
+                    "// If that number is not reached, and evolve_only_with_lucky_egg is true, evolution will be skipped": {},
+                    "// If that number is not reached, and evolve_only_with_lucky_egg is false,": {},
+                    "// evolution will be performed without using a lucky egg": {},
                 "minimum_evolve_for_lucky_egg": 90,
+                    "// the 'keep' parameter let you define what pokemons you consider are the 'best'. These Pokemons": {},
+                    "// will be keep and evolved. Note that Pokemons are evaluated inside their whole family": {},
+                    "// Multiple way of ranking can be defined. Following configuration let you keep the best iv,": {},
+                    "// the best ncp and the best cp": {},
                 "keep": [
                     {
+                            "// Following setting let you keep the best iv of the family": {},
+                            "// the 'top' parameter allow you to define how many Pokemons you want to keep": {},
+                            "// at the top of your ranking. If several Pokemons get the same score, they are": {},
+                            "// considered equal. Thus, top=1 might result in keeping more than 1 Pokemon.": {},
                         "top": 1,
+                            "// the 'evolve' parameter let you choose if you want to evolve the Pokemons you keep": {},
                         "evolve": true,
-                        "// Available sorting keys are:": true,
-                        "// iv, cp, ncp, ivcp, max_cp, iv_attack, iv_defense, iv_stamina, hp_max, level": true,
+                            "// the 'sort' parameter define how you want to rank your pokemons": {},
+                            "// Critera are sorted fro, the most important to the least important.": {},
+                            "// Available criteria are:": {},
+                            "// 'iv' = individual value": [},
+                            "// 'ivcp' = iv weigted so that for equal iv, attack > defense > stamina": {},
+                            "// 'cp' = combat power (can be increased with candies)": {},
+                            "// 'cp_exact' = combar power (not rounded)": {},
+                            "// 'ncp' (normalized cp) or 'cp_percent' = ratio cp / max_cp": {},
+                            "// iv_attack = attach component of iv": {},
+                            "// iv_defense = defense component of iv": {},
+                            "// iv_stamina = stamina component of iv": {},
+                            "// dps = raw dps based on the moves of the pokemon": {},
+                            "// dps_attack = average dps when attacking": {},
+                            "// dps_defense = average dps when defending": {},
+                            "// Note that the more criteria you add to this list, the less likely Pokemons": {},
+                            "// will be equals": {},
                         "sort": ["iv"]
                     },
                     {
+                        "// Following setting let you keep keep the best normalized cp of the family": {},
+                        "// That is the Pokemon with higher CP once fully evolved": {},
                         "top": 1,
                         "evolve": true,
                         "sort": ["ncp"]
                     },
                     {
+                        "// Following setting let you keep keep the best cp of the family.": {},
+                        "// But will not evolve it further (in favor of the best ncp)": {},
                         "top": 1,
                         "evolve": false,
                         "sort": ["cp"]

pokemongo_bot/cell_workers/evolve_pokemon.py

@@ -107,7 +107,9 @@ def _execute_pokemon_evolve(self, pokemon, cache):
                     'pokemon': pokemon.name,
                     'iv': pokemon.iv,
                     'cp': pokemon.cp,
-                    'xp': 0
+                    'ncp': '?',
+                    'dps': '?',
+                    'xp': '?'
                 }
             )
             inventory.candies().get(pokemon.pokemon_id).consume(pokemon.evolution_cost)

pokemongo_bot/cell_workers/pokemon_optimizer.py

@@ -17,6 +17,7 @@ def initialize(self):
 
         self.config_transfer = self.config.get("transfer", False)
         self.config_evolve = self.config.get("evolve", False)
+        self.config_use_candies_for_xp = self.config.get("use_candies_for_xp", True)
         self.config_use_lucky_egg = self.config.get("use_lucky_egg", False)
         self.config_evolve_only_with_lucky_egg = self.config.get("evolve_only_with_lucky_egg", True)
         self.config_minimum_evolve_for_lucky_egg = self.config.get("minimum_evolve_for_lucky_egg", 90)
@@ -56,6 +57,9 @@ def parse_inventory(self):
         for pokemon in inventory.pokemons().all():
             family_id = pokemon.first_evolution_id
             setattr(pokemon, "ncp", pokemon.cp_percent)
+            setattr(pokemon, "dps", pokemon.moveset.dps)
+            setattr(pokemon, "dps_attack", pokemon.moveset.dps_attack)
+            setattr(pokemon, "dps_defense", pokemon.moveset.dps_defense)
 
             self.family_by_family_id.setdefault(family_id, []).append(pokemon)
 
@@ -173,39 +177,58 @@ def get_evolution_plan(self, family_id, family, evolve_best, keep_best):
             next_evo.name = inventory.pokemons().name_for(next_pid)
             evolve_best.append(next_evo)
 
-        # Compute how many crap we should keep if we want to batch evolve them for xp
-        junior_evolution_cost = inventory.pokemons().evolution_cost_for(family_id)
+        if self.config_use_candies_for_xp:
+            # Compute how many crap we should keep if we want to batch evolve them for xp
+            junior_evolution_cost = inventory.pokemons().evolution_cost_for(family_id)
 
-        # transfer + keep_for_evo = len(crap)
-        # leftover_candies = candies - len(crap) + transfer * 1
-        # keep_for_evo = leftover_candies / junior_evolution_cost
-        #
-        # keep_for_evo = (candies - len(crap) + transfer) / junior_evolution_cost
-        # keep_for_evo = (candies - keep_for_evo) / junior_evolution_cost
+            # transfer + keep_for_evo = len(crap)
+            # leftover_candies = candies - len(crap) + transfer * 1
+            # keep_for_evo = leftover_candies / junior_evolution_cost
+            #
+            # keep_for_evo = (candies - len(crap) + transfer) / junior_evolution_cost
+            # keep_for_evo = (candies - keep_for_evo) / junior_evolution_cost
 
-        if (candies > 0) and junior_evolution_cost:
-            keep_for_evo = int(candies / (junior_evolution_cost + 1))
-        else:
-            keep_for_evo = 0
+            if (candies > 0) and junior_evolution_cost:
+                keep_for_evo = int(candies / (junior_evolution_cost + 1))
+            else:
+                keep_for_evo = 0
 
-        evo_crap = [p for p in crap if p.has_next_evolution() and p.evolution_cost == junior_evolution_cost][:keep_for_evo]
-        transfer = [p for p in crap if p not in evo_crap]
+            evo_crap = [p for p in crap if p.has_next_evolution() and p.evolution_cost == junior_evolution_cost][:keep_for_evo]
+            transfer = [p for p in crap if p not in evo_crap]
+        else:
+            evo_crap = []
+            transfer = crap
 
         return (transfer, can_evolve_best, evo_crap)
 
     def apply_optimization(self, transfer, evo):
         for pokemon in transfer:
             self.transfer_pokemon(pokemon)
 
+        if self.config_evolve:
+            if len(evo) < self.config_minimum_evolve_for_lucky_egg:
+                self.logger.info("Skipping evolution step. Not enough Pokemons to evolve")
+                return
+
+        if self.config_evolve and (len(evo) < self.config_minimum_evolve_for_lucky_egg):
+            self.logger.info("Skipping evolution step. Not enough Pokemons to evolve")
+            return
+
         if self.config_evolve and self.config_use_lucky_egg:
+            if len(evo) == 0:
+                return
+
             lucky_egg = inventory.items().get(Item.ITEM_LUCKY_EGG.value)  # @UndefinedVariable
 
-            if lucky_egg.count == 0:
-                if self.config_evolve_only_with_lucky_egg:
-                    self.logger.info("Skipping evolution step. No lucky egg available")
-                    return
-            elif len(evo) >= self.config_minimum_evolve_for_lucky_egg:
-                self.use_lucky_egg()
+            if self.config_evolve_only_with_lucky_egg and (lucky_egg.count == 0):
+                self.logger.info("Skipping evolution step. No lucky egg available")
+                return
+
+            if len(evo) < self.config_minimum_evolve_for_lucky_egg:
+                self.logger.info("Skipping evolution step. Not enough Pokemons (%s) to evolve", len(evo))
+                return
+
+            self.use_lucky_egg()
 
         self.logger.info("Evolving %s Pokemons", len(evo))
 
@@ -219,10 +242,12 @@ def transfer_pokemon(self, pokemon):
             pass
 
         self.emit_event("pokemon_release",
-                        formatted="Exchanged {pokemon} [IV {iv}] [CP {cp}]",
+                        formatted="Exchanged {pokemon} [IV {iv}] [CP {cp}] [NCP {ncp}] [DPS {dps}]",
                         data={"pokemon": pokemon.name,
                               "iv": pokemon.iv,
-                              "cp": pokemon.cp})
+                              "cp": pokemon.cp,
+                              "ncp": round(pokemon.ncp, 2),
+                              "dps": round(pokemon.dps, 2)})
 
         if self.config_transfer:
             inventory.candies().get(pokemon.pokemon_id).add(1)
@@ -231,30 +256,31 @@ def transfer_pokemon(self, pokemon):
     def use_lucky_egg(self):
         lucky_egg = inventory.items().get(Item.ITEM_LUCKY_EGG.value)  # @UndefinedVariable
 
-        if self.config_evolve and self.config_use_lucky_egg:
-            response_dict = self.bot.use_lucky_egg()
-            lucky_egg.remove(1)
-        else:
-            response_dict = {"responses": {"USE_ITEM_XP_BOOST": {"result": 1}}}
+        if lucky_egg.count == 0:
+            return
+
+        response_dict = self.bot.use_lucky_egg()
 
         if not response_dict:
             self.emit_event("lucky_egg_error",
                             level='error',
                             formatted="Failed to use lucky egg!")
-            return False
+            return
 
         result = response_dict.get("responses", {}).get("USE_ITEM_XP_BOOST", {}).get("result", 0)
 
         if result == 1:
+            lucky_egg.remove(1)
+
             self.emit_event("used_lucky_egg",
                             formatted="Used lucky egg ({amount_left} left).",
                             data={"amount_left": lucky_egg.count})
-            return True
+            return
         else:
             self.emit_event("lucky_egg_error",
                             level='error',
                             formatted="Failed to use lucky egg!")
-            return False
+            return
 
     def evolve_pokemon(self, pokemon):
         if self.config_evolve:
@@ -270,10 +296,12 @@ def evolve_pokemon(self, pokemon):
 
         if result == 1:
             self.emit_event("pokemon_evolved",
-                            formatted="Evolved {pokemon} [IV {iv}] [CP {cp}] [+{xp} xp]",
+                            formatted="Evolved {pokemon} [IV {iv}] [CP {cp}] [NCP {ncp}] [DPS {dps}] [+{xp} xp]",
                             data={"pokemon": pokemon.name,
                                   "iv": pokemon.iv,
                                   "cp": pokemon.cp,
+                                  "ncp": round(pokemon.ncp, 2),
+                                  "dps": round(pokemon.dps, 2),
                                   "xp": xp})
 
             if self.config_evolve:

pokemongo_bot/cell_workers/transfer_pokemon.py

@@ -153,7 +153,9 @@ def release_pokemon(self, pokemon):
             data={
                 'pokemon': pokemon.name,
                 'cp': pokemon.cp,
-                'iv': pokemon.iv
+                'iv': pokemon.iv,
+                'ncp': '?',
+                'dps': '?'
             }
         )
         action_delay(self.bot.config.action_wait_min, self.bot.config.action_wait_max)