Bump version: 0.23.1.2 → 0.23.2

HISTORY.rst

@@ -2,6 +2,29 @@
 History
 =======
 
+0.23.2 (2020-12-01)
+-------------------
+* Added concurrency checks to guard against simultaneous fighting/wam'ing/traveling *(Note: Probably will make it into a decorator at some time)*
+
+0.23.1 (2020-12-01)
+-------------------
+* Separated battle finding logic from CitizenMilitary.find_battle_and_fight method
+* Base dmg calculations
+* Get max hit value for divisions on current side
+* Added method to get division stats
+* Wheel of fortune updates
+
+0.23.0 (2020-11-26)
+-------------------
+* ***0.23 - last supported version for Python 3.7.***
+* Added `Config.maverick` switch, to allow/deny automated fighting in non native divisions if the player has MaverickPack
+* Added `CitizenMedia.get_article(article_id:int)` method to get article data
+* Added `CitizenMedia.delete_article(article_id:int)` method to delete article
+* Fixed `CitizenTravel.travel_to_region(region_id:int)` method
+* Added `CitizenAnniversary.collect_map_quest_node(node_id:int, extra:bool=False)` to collect also extra rewards
+* Fixed `CitizenTasks.work()` when employer out of money - resign and find a new job
+* Fixed `CitizenEconomy.post_market_offer()`
+
 0.22.3 (2020-11-16)
 -------------------
 * Fixed round to even bug when doing wam and not enough raw.

erepublik/__init__.py

@@ -4,7 +4,7 @@
 
 __author__ = """Eriks Karls"""
 __email__ = 'eriks@72.lv'
-__version__ = '0.22.3.1'
+__version__ = '0.23.2'
 
 from erepublik import classes, utils, constants
 from erepublik.citizen import Citizen

erepublik/access_points.py

@@ -161,8 +161,10 @@ class ErepublikAnniversaryAPI(CitizenBaseAPI):
         data = {'nodeId': node_id, '_token': self.token, "currencyCost": currency_amount}
         return self.post(f"{self.url}/main/map-rewards-speedup", data=data)
 
-    def _post_map_rewards_claim(self, node_id: int) -> Response:
+    def _post_map_rewards_claim(self, node_id: int, extra: bool = False) -> Response:
         data = {'nodeId': node_id, '_token': self.token}
+        if extra:
+            data['claimExtra'] = 1
         return self.post(f"{self.url}/main/map-rewards-claim", data=data)
 
     def _post_main_wheel_of_fortune_spin(self, cost) -> Response:
@@ -176,6 +178,9 @@ class ErepublikArticleAPI(CitizenBaseAPI):
     def _get_main_article_json(self, article_id: int) -> Response:
         return self.get(f"{self.url}/main/articleJson/{article_id}")
 
+    def _get_main_delete_article(self, article_id: int) -> Response:
+        return self.get(f"{self.url}/main/delete-article/{article_id}/1")
+
     def _post_main_article_comments(self, article_id: int, page: int = 1) -> Response:
         data = dict(_token=self.token, articleId=article_id, page=page)
         if page:
@@ -383,6 +388,9 @@ class ErepublikLocationAPI(CitizenBaseAPI):
 
 
 class ErepublikMilitaryAPI(CitizenBaseAPI):
+    def _get_military_battle_stats(self, battle_id: int, division: int, division_id: int):
+        return self.get(f"{self.url}/military/battle-stats/{battle_id}/{division}/{division_id}")
+
     def _get_military_battlefield_choose_side(self, battle_id: int, side_id: int) -> Response:
         return self.get(f"{self.url}/military/battlefield-choose-side/{battle_id}/{side_id}")
 

erepublik/citizen.py

@@ -33,13 +33,16 @@ class BaseCitizen(access_points.CitizenAPI):
     maverick: bool = False
 
     eday: int = 0
+    wheel_of_fortune: bool
 
+    debug: bool = False
     config: classes.Config = None
     energy: classes.Energy = None
     details: classes.Details = None
     politics: classes.Politics = None
     reporter: classes.Reporter = None
     stop_threads: Event = None
+    concurrency_lock: Event = None
     telegram: classes.TelegramBot = None
 
     r: Response = None
@@ -56,12 +59,14 @@ class BaseCitizen(access_points.CitizenAPI):
         self.my_companies = classes.MyCompanies(self)
         self.reporter = classes.Reporter(self)
         self.stop_threads = Event()
+        self.concurrency_lock = Event()
         self.telegram = classes.TelegramBot(stop_event=self.stop_threads)
 
         self.config.email = email
         self.config.password = password
         self.inventory = {}
         self.inventory_status = dict(used=0, total=0)
+        self.wheel_of_fortune = False
 
     def get_csrf_token(self):
         """
@@ -230,6 +235,9 @@ class BaseCitizen(access_points.CitizenAPI):
             self.politics.is_party_president = bool(party.get('is_party_president'))
             self.politics.party_slug = f"{party.get('stripped_title')}-{party.get('party_id')}"
 
+        self.wheel_of_fortune = bool(
+            re.search(r'<a id="launch_wof" class="powerspin_sidebar( show_free)?" href="javascript:">', html))
+
     def update_inventory(self):
         """
         Updates class properties and returns structured inventory.
@@ -416,6 +424,19 @@ class BaseCitizen(access_points.CitizenAPI):
         else:
             sleep(seconds)
 
+    def set_debug(self, debug: bool):
+        self.debug = bool(debug)
+        self._req.debug = bool(debug)
+
+    def __wait_for_concurrency_cleared(self) -> bool:
+        self.concurrency_lock.wait(600)
+        if self.concurrency_lock.is_set():
+            self.write_log('Unable to acquire concurrency lock in 10min!')
+            if self.debug:
+                self.report_error("Lock not released in 10min!")
+            return False
+        return True
+
     def to_json(self, indent: bool = False) -> str:
         return utils.json.dumps(self, cls=classes.MyJSONEncoder, indent=4 if indent else None)
 
@@ -731,31 +752,41 @@ class CitizenAnniversary(BaseCitizen):
     def start_unlocking_map_quest_node(self, node_id: int):
         return self._post_map_rewards_unlock(node_id)
 
-    def collect_map_quest_node(self, node_id: int):
-        return self._post_map_rewards_claim(node_id)
+    def collect_map_quest_node(self, node_id: int, extra: bool = False):
+        return self._post_map_rewards_claim(node_id, extra)
 
     def speedup_map_quest_node(self, node_id: int):
         node = self.get_anniversary_quest_data().get('cities', {}).get(str(node_id), {})
         return self._post_map_rewards_speedup(node_id, node.get("skipCost", 0))
 
     def spin_wheel_of_fortune(self, max_cost=0, spin_count=0):
-        def _write_spin_data(cost, cc, prize):
-            self._report_action("WHEEL_SPIN", f"Cost: {cost:4d} | Currency left: {cc:,} | Prize: {prize}")
+        if not self.config.spin_wheel_of_fortune:
+            self.write_log("Unable to spin wheel of fortune because 'config.spin_wheel_of_fortune' is False")
+            return
 
+        def _write_spin_data(cost: int, prize: str):
+            self._report_action("WHEEL_SPIN", f"Cost: {cost:4d} | Currency left: {self.details.cc:,} | Prize: {prize}")
+
+        if not self.wheel_of_fortune:
+            self.update_citizen_info()
         base = self._post_main_wheel_of_fortune_build().json()
         current_cost = 0 if base.get('progress').get('free_spin') else base.get('cost')
         current_count = base.get('progress').get('spins')
+        prizes = base.get('prizes')
         if not max_cost and not spin_count:
             r = self._post_main_wheel_of_fortune_spin(current_cost).json()
-            _write_spin_data(current_cost, r.get('account'),
-                             base.get('prizes').get('prizes').get(str(r.get('result'))).get('tooltip'))
+            _write_spin_data(current_cost, prizes.get('prizes').get(str(r.get('result'))).get('tooltip'))
         else:
             while max_cost >= current_cost if max_cost else spin_count >= current_count if spin_count else False:
                 r = self._spin_wheel_of_loosing(current_cost)
                 current_count += 1
+                prize_name = prizes.get('prizes').get(str(r.get('result'))).get('tooltip')
+                if r.get('result') == 7:
+                    prize_name += f" - {prizes.get('jackpot').get(str(r.get('jackpot'))).get('tooltip')}"
+                _write_spin_data(current_cost, prize_name)
                 current_cost = r.get('cost')
-                _write_spin_data(current_cost, r.get('account'),
-                                 base.get('prizes').get('prizes').get(str(r.get('result'))).get('tooltip'))
+                if r.get('jackpot', 0) == 3:
+                    return
 
     def _spin_wheel_of_loosing(self, current_cost: int) -> Dict[str, Any]:
         r = self._post_main_wheel_of_fortune_spin(current_cost).json()
@@ -808,7 +839,14 @@ class CitizenTravel(BaseCitizen):
         if data.get('alreadyInRegion'):
             return True
         else:
-            country = constants.COUNTRIES[data.get('preselectCountryId')]
+            country = None
+            for country_data in data.get('countries').values():
+                if region_id in country_data.get('regions'):
+                    country = constants.COUNTRIES[country_data.get('id')]
+                    break
+
+            if country is None:
+                raise classes.ErepublikException('Region not found!')
 
             if self._travel(country, region_id):
                 self._report_action("TRAVEL", "Traveled to region")
@@ -909,6 +947,9 @@ class CitizenCompanies(BaseCitizen):
     def _work_as_manager(self, wam_holding: classes.Holding) -> Optional[Dict[str, Any]]:
         if self.restricted_ip:
             return None
+        if not self.__wait_for_concurrency_cleared():
+            return
+        self.concurrency_lock.set()
         self.update_companies()
         data = {"action_type": "production"}
         extra = {}
@@ -930,6 +971,7 @@ class CitizenCompanies(BaseCitizen):
             data.update(extra)
             if not self.details.current_region == wam_holding.region:
                 self.write_log("Unable to work as manager because of location - please travel!")
+                self.concurrency_lock.clear()
                 return
 
             employ_factories = self.my_companies.get_employable_factories()
@@ -938,6 +980,7 @@ class CitizenCompanies(BaseCitizen):
 
             response = self._post_economy_work("production", wam=[c.id for c in wam_list],
                                                employ=employ_factories).json()
+            self.concurrency_lock.clear()
             return response
 
     def update_companies(self):
@@ -1008,6 +1051,9 @@ class CitizenEconomy(CitizenTravel):
 
             global_cheapest = self.get_market_offers("House", q)[f"q{q}"]
             if global_cheapest.price + 200 < local_cheapest.price:
+                if not self.__wait_for_concurrency_cleared():
+                    return self.check_house_durability()
+                self.concurrency_lock.set()
                 if self.travel_to_country(global_cheapest.country):
                     buy = self.buy_from_market(global_cheapest.offer_id, 1)
                 else:
@@ -1025,6 +1071,7 @@ class CitizenEconomy(CitizenTravel):
             self.activate_house(q)
         if original_region[1] != self.details.current_region:
             self._travel(*original_region)
+            self.concurrency_lock.clear()
         return self.check_house_durability()
 
     def renew_houses(self, forced: bool = False) -> Dict[int, datetime]:
@@ -1161,6 +1208,9 @@ class CitizenEconomy(CitizenTravel):
             amount = offer.amount
         traveled = False
         if not self.details.current_country == offer.country:
+            if not self.__wait_for_concurrency_cleared():
+                return {'error': True, 'message': 'Concurrency locked for travel'}
+            self.concurrency_lock.set()
             traveled = True
             self.travel_to_country(offer.country)
         ret = self._post_economy_marketplace_actions('buy', offer=offer.offer_id, amount=amount)
@@ -1172,6 +1222,7 @@ class CitizenEconomy(CitizenTravel):
             self._report_action("BOUGHT_PRODUCTS", json_ret.get('message'), kwargs=json_ret)
         if traveled:
             self.travel_to_residence()
+            self.concurrency_lock.clear()
         return json_ret
 
     def get_market_offers(
@@ -1437,6 +1488,19 @@ class CitizenMedia(BaseCitizen):
                 "\n".join(["{}: {}".format(k, v) for k, v in kinds.items()]), kind
             ))
 
+    def get_article(self, article_id: int) -> Dict[str, Any]:
+        return self._get_main_article_json(article_id).json()
+
+    def delete_article(self, article_id: int) -> NoReturn:
+        article_data = self.get_article(article_id)
+        if article_data and article_data['articleData']['canDelete']:
+            self._report_action("ARTICLE_DELETE",
+                                f"Attempting to delete article '{article_data['article']['title']}' (#{article_id})",
+                                kwargs=article_data)
+            self._get_main_delete_article(article_id)
+        else:
+            self.write_log(f"Unable to delete article (#{article_id})!")
+
 
 class CitizenMilitary(CitizenTravel):
     all_battles: Dict[int, classes.Battle] = None
@@ -1608,6 +1672,7 @@ class CitizenMilitary(CitizenTravel):
     def get_cheap_tp_divisions(self) -> Dict[str, List[Tuple[int, classes.BattleDivision]]]:
         air_divs: List[Tuple[int, classes.BattleDivision]] = []
         ground_divs: List[Tuple[int, classes.BattleDivision]] = []
+        check_maverick = self.maverick and self.config.maverick
         for battle in reversed(self.sorted_battles(True, True)):
             for division in battle.div.values():
                 is_start_ok = utils.good_timedelta(division.battle.start, timedelta(minutes=-1)) < self.now
@@ -1620,7 +1685,7 @@ class CitizenMilitary(CitizenTravel):
                         else:
                             air_divs.append((medal.get('1').get('raw_value'), division))
                     elif not division.is_air and self.config.ground:
-                        if not division.div == self.division and not self.maverick:
+                        if not division.div == self.division and not check_maverick:
                             continue
                         division_medals = self.get_battle_round_data(division)
                         medal = division_medals[self.details.citizenship == division.battle.defender.country]
@@ -1637,46 +1702,57 @@ class CitizenMilitary(CitizenTravel):
     def has_battle_contribution(self):
         return bool(self.__last_war_update_data.get("citizen_contribution", []))
 
+    def find_battle_to_fight(self, silent: bool = False) -> Tuple[classes.Battle, classes.BattleDivision, classes.BattleSide]:
+        self.update_war_info()
+        for battle in self.sorted_battles(self.config.sort_battles_time):
+            if not isinstance(battle, classes.Battle):
+                continue
+            battle_zone: Optional[classes.BattleDivision] = None
+            for div in battle.div.values():
+                if div.terrain == 0:
+                    if div.div_end:
+                        continue
+                    if self.config.air and div.is_air:
+                        battle_zone = div
+                        break
+                    elif self.config.ground and not div.is_air and (div.div == self.division or (self.maverick and self.config.maverick)):
+                        battle_zone = div
+                        break
+                    else:
+                        continue
+            if not battle_zone:
+                continue
+            allies = battle.invader.deployed + battle.defender.deployed + [battle.invader.country,
+                                                                           battle.defender.country]
+
+            travel_needed = self.details.current_country not in allies
+
+            if battle.is_rw:
+                side = battle.defender if self.config.rw_def_side else battle.invader
+            else:
+                defender_side = self.details.current_country in battle.defender.allies + [battle.defender.country, ]
+                side = battle.defender if defender_side else battle.invader
+
+            if not silent:
+                self.write_log(battle)
+
+            travel = (self.config.travel_to_fight and self.should_travel_to_fight() or self.config.force_travel) \
+                if travel_needed else True
+
+            if not travel:
+                continue
+            yield battle, battle_zone, side
+
     def find_battle_and_fight(self):
         if self.should_fight()[0]:
             self.write_log("Checking for battles to fight in...")
-            for battle in self.sorted_battles(self.config.sort_battles_time):
-                if not isinstance(battle, classes.Battle):
-                    continue
-                battle_zone: Optional[classes.BattleDivision] = None
-                for div in battle.div.values():
-                    if div.terrain == 0:
-                        if div.div_end:
-                            continue
-                        if self.config.air and div.is_air:
-                            battle_zone = div
-                            break
-                        elif self.config.ground and not div.is_air and (div.div == self.division or self.maverick):
-                            battle_zone = div
-                            break
-                        else:
-                            continue
-                if not battle_zone:
-                    continue
+            for battle, division, side in self.find_battle_to_fight():
+
                 allies = battle.invader.deployed + battle.defender.deployed + [battle.invader.country,
                                                                                battle.defender.country]
 
                 travel_needed = self.details.current_country not in allies
 
-                if battle.is_rw:
-                    side = battle.defender if self.config.rw_def_side else battle.invader
-                else:
-                    defender_side = self.details.current_country in battle.defender.allies + [battle.defender.country, ]
-                    side = battle.defender if defender_side else battle.invader
-
-                self.write_log(battle)
-
-                travel = (self.config.travel_to_fight and self.should_travel_to_fight() or self.config.force_travel) \
-                    if travel_needed else True
-
-                if not travel:
-                    continue
-
                 if battle.start > self.now:
                     self.sleep(utils.get_sleep_seconds(battle.start))
 
@@ -1692,10 +1768,15 @@ class CitizenMilitary(CitizenTravel):
 
                     if not self.travel_to_battle(battle, countries_to_travel):
                         break
-                if self.change_division(battle, battle_zone):
-                    self.set_default_weapon(battle, battle_zone)
-                    self.fight(battle, battle_zone, side)
+
+                if not self.__wait_for_concurrency_cleared():
+                    return
+                self.concurrency_lock.set()
+                if self.change_division(battle, division):
+                    self.set_default_weapon(battle, division)
+                    self.fight(battle, division, side)
                     self.travel_to_residence()
+                    self.concurrency_lock.clear()
                     break
 
     def fight(self, battle: classes.Battle, division: classes.BattleDivision, side: classes.BattleSide = None,
@@ -1811,6 +1892,10 @@ class CitizenMilitary(CitizenTravel):
         :return: Deployed count
         :rtype: int
         """
+
+        if not self.__wait_for_concurrency_cleared():
+            return 0
+        self.concurrency_lock.set()
         if not isinstance(count, int) or count < 1:
             count = 1
         has_traveled = False
@@ -1844,6 +1929,7 @@ class CitizenMilitary(CitizenTravel):
             self.travel_to_residence()
 
         self._report_action("MILITARY_BOMB", f"Deployed {deployed_count} bombs in battle {battle.id}")
+        self.concurrency_lock.clear()
         return deployed_count
 
     def change_division(self, battle: classes.Battle, division: classes.BattleDivision) -> bool:
@@ -1974,13 +2060,8 @@ class CitizenMilitary(CitizenTravel):
             count = self.energy.food_fights
             msg = "Fighting all-in. Doing %i hits" % count
 
-        # All-in for AIR battles
-        elif all([self.config.air, self.config.all_in, self.energy.available >= self.energy.limit]):
-            count = self.energy.food_fights
-            msg = "Fighting all-in in AIR. Doing %i hits" % count
-
         # Get to next Energy +1
-        elif self.next_reachable_energy and self.config.next_energy:
+        elif self.config.next_energy and self.next_reachable_energy:
             count = self.next_reachable_energy
             msg = "Fighting for +1 energy. Doing %i hits" % count
 
@@ -2002,6 +2083,21 @@ class CitizenMilitary(CitizenTravel):
         return (r_json.get(str(battle.invader.id)).get("fighterData"),
                 r_json.get(str(battle.defender.id)).get("fighterData"))
 
+    def get_battle_division_stats(self, division: classes.BattleDivision) -> Dict[str, Any]:
+        battle = division.battle
+        r = self._get_military_battle_stats(battle.id, division.div, division.id)
+        return r.json()
+
+    def get_division_max_hit(self, division: classes.BattleDivision) -> int:
+        """ Returns max hit in division for current side (if not on either side returns 0)
+
+        :param division: BattleDivision for which to get max hit value
+        :type division: classes.BattleDivision
+        :return: max hit value
+        :rtype: int
+        """
+        return self.get_battle_division_stats(division).get('maxHit', -1)
+
     def schedule_attack(self, war_id: int, region_id: int, region_name: str, at_time: datetime):
         if at_time:
             self.sleep(utils.get_sleep_seconds(at_time))
@@ -2336,8 +2432,6 @@ class CitizenTasks(BaseCitizen):
 
 class Citizen(CitizenAnniversary, CitizenCompanies, CitizenEconomy, CitizenLeaderBoard,
               CitizenMedia, CitizenMilitary, CitizenPolitics, CitizenSocial, CitizenTasks):
-    debug: bool = False
-
     def __init__(self, email: str = "", password: str = "", auto_login: bool = False):
         super().__init__(email, password)
         self._last_full_update = constants.min_datetime
@@ -2437,10 +2531,6 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenEconomy, CitizenLeade
             for info in data.values():
                 self.reporter.report_action("NEW_MEDAL", info)
 
-    def set_debug(self, debug: bool):
-        self.debug = bool(debug)
-        self._req.debug = bool(debug)
-
     def set_pin(self, pin: str):
         self.details.pin = str(pin[:4])
 
@@ -2517,7 +2607,7 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenEconomy, CitizenLeade
                 start_time = utils.good_timedelta(start_time, timedelta(minutes=30))
                 self.send_state_update()
                 self.send_inventory_update()
-                self.reporter.report_action('COMPANIES', json_val=self.my_companies.as_dict)
+                self.send_my_companies_update()
                 sleep_seconds = (start_time - self.now).total_seconds()
                 self.stop_threads.wait(sleep_seconds if sleep_seconds > 0 else 0)
         except:  # noqa
@@ -2533,6 +2623,9 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenEconomy, CitizenLeade
     def send_inventory_update(self):
         self.reporter.report_action("INVENTORY", json_val=self.get_inventory(True))
 
+    def send_my_companies_update(self):
+        self.reporter.report_action('COMPANIES', json_val=self.my_companies.as_dict)
+
     def eat(self):
         """
         Try to eat food
@@ -2610,7 +2703,8 @@ class Citizen(CitizenAnniversary, CitizenCompanies, CitizenEconomy, CitizenLeade
 
                     if not best_offer.country == self.details.current_country:
                         self.travel_to_country(best_offer.country)
-                    self._report_action("ECONOMY_BUY", f"Attempting to buy {amount} {raw_kind} for {best_offer.price*amount}cc")
+                    self._report_action("ECONOMY_BUY",
+                                        f"Attempting to buy {amount} {raw_kind} for {best_offer.price * amount}cc")
                     rj = self.buy_from_market(amount=amount, offer=best_offer.offer_id)
                     if not rj.get('error'):
                         amount_needed -= amount

erepublik/classes.py

@@ -357,6 +357,8 @@ class Config:
     telegram = True
     telegram_chat_id = 0
     telegram_token = ""
+    maverick = False
+    spin_wheel_of_fortune = False
 
     def __init__(self):
         self.auto_sell = []
@@ -389,6 +391,8 @@ class Config:
         self.telegram = True
         self.telegram_chat_id = 0
         self.telegram_token = ""
+        self.maverick = False
+        self.spin_wheel_of_fortune = False
 
     @property
     def as_dict(self):
@@ -397,10 +401,11 @@ class Config:
                     fight=self.fight, air=self.air, ground=self.ground, all_in=self.all_in,
                     next_energy=self.next_energy, boosters=self.boosters, travel_to_fight=self.travel_to_fight,
                     always_travel=self.always_travel, epic_hunt=self.epic_hunt, epic_hunt_ebs=self.epic_hunt_ebs,
-                    rw_def_side=self.rw_def_side, interactive=self.interactive,
+                    rw_def_side=self.rw_def_side, interactive=self.interactive, maverick=self.maverick,
                     continuous_fighting=self.continuous_fighting, auto_buy_raw=self.auto_buy_raw,
                     force_wam=self.force_wam, sort_battles_time=self.sort_battles_time, force_travel=self.force_travel,
-                    telegram=self.telegram, telegram_chat_id=self.telegram_chat_id, telegram_token=self.telegram_token)
+                    telegram=self.telegram, telegram_chat_id=self.telegram_chat_id, telegram_token=self.telegram_token,
+                    spin_wheel_of_fortune=self.spin_wheel_of_fortune)
 
 
 class Energy:
@@ -714,11 +719,11 @@ class BattleSide:
 
     def __repr__(self):
         side_text = "Defender" if self.is_defender else "Invader "
-        return f"<BattleSide: {side_text} {self.country.name}|{self.points:02d}p>"
+        return f"<BattleSide: {side_text} {self.country.name}|{self.points:>2d}p>"
 
     def __str__(self):
         side_text = "Defender" if self.is_defender else "Invader "
-        return f"{side_text} {self.country.name} - {self.points:02d} points"
+        return f"{side_text} {self.country.name} - {self.points:>2d} points"
 
     def __format__(self, format_spec):
         return self.country.iso
@@ -784,7 +789,7 @@ class BattleDivision:
         return constants.TERRAINS[self.terrain]
 
     def __str__(self):
-        base_name = f"Div #{self.id} d{self.div}"
+        base_name = f"D{self.div} #{self.id}"
         if self.terrain:
             base_name += f" ({self.terrain_display})"
         if self.div_end:
@@ -894,8 +899,8 @@ class Battle:
         else:
             time_part = "-{}".format(self.start - time_now)
 
-        return (f"Battle {self.id} for {self.region_name[:16]} | "
-                f"{self.invader} : {self.defender} | Round time {time_part}")
+        return (f"Battle {self.id} for {self.region_name[:16]:16} | "
+                f"{self.invader} : {self.defender} | Round time {time_part} | {'R'+str(self.zone_id):>3}")
 
     def __repr__(self):
         return f"<Battle #{self.id} {self.invader}:{self.defender} R{self.zone_id}>"

erepublik/utils.py

@@ -338,17 +338,8 @@ def calculate_hit(strength: float, rang: int, tp: bool, elite: bool, ne: bool, b
     base_wpn = (1 + Decimal(str(weapon / 100)))
     dmg = 10 * base_str * base_rnk * base_wpn
 
-    if elite:
-        dmg = dmg * 11 / 10
-
-    if tp and rang >= 70:
-        dmg = dmg * (1 + Decimal((rang - 69) / 10))
-
-    dmg = dmg * (100 + booster) / 100
-
-    if ne:
-        dmg = dmg * 11 / 10
-    return round(dmg, dec)
+    dmg = get_final_hit_dmg(dmg, rang, tp=tp, elite=elite, ne=ne, booster=booster)
+    return Decimal(round(dmg, dec))
 
 
 def get_ground_hit_dmg_value(citizen_id: int, natural_enemy: bool = False, true_patriot: bool = False,
@@ -371,6 +362,19 @@ def get_air_hit_dmg_value(citizen_id: int, natural_enemy: bool = False, true_pat
     return calculate_hit(0, rang, true_patriot, elite, natural_enemy, booster, weapon_power)
 
 
+def get_final_hit_dmg(base_dmg: Union[Decimal, float, str], rang: int,
+                      tp: bool = False, elite: bool = False, ne: bool = False, booster: int = 0) -> Decimal:
+    dmg = Decimal(str(base_dmg))
+
+    if elite:
+        dmg = dmg * 11 / 10
+    if tp and rang >= 70:
+        dmg = dmg * (1 + Decimal((rang - 69) / 10))
+    dmg = dmg * (100 + booster) / 100
+    if ne:
+        dmg = dmg * 11 / 10
+    return Decimal(dmg)
+
 # def _clear_up_battle_memory(battle):
 #     del battle.invader._battle, battle.defender._battle
 #     for div_id, division in battle.div.items():

requirements_dev.txt

@@ -4,16 +4,16 @@ edx-sphinx-theme==1.5.0
 flake8==3.8.4
 ipython>=7.19.0
 isort==5.6.4
-pip==20.2.4
-PyInstaller==4.0
+pip==20.3
+PyInstaller==4.1
 pytz==2020.4
 pytest==6.1.2
-responses==0.12.0
+responses==0.12.1
 setuptools==50.3.2
-Sphinx==3.3.0
-requests==2.24.0
+Sphinx==3.3.1
+requests==2.25.0
 PySocks==1.7.1
 tox==3.20.1
 twine==3.2.0
-watchdog==0.10.3
+watchdog==0.10.4
 wheel==0.35.1

setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.22.3.1
+current_version = 0.23.2
 commit = True
 tag = True
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)\.?(?P<dev>\d+)?

setup.py

@@ -13,7 +13,7 @@ with open('HISTORY.rst') as history_file:
 
 requirements = [
     'pytz==2020.4',
-    'requests==2.24.0',
+    'requests==2.25.0',
     'PySocks==1.7.1'
 ]
 
@@ -21,7 +21,7 @@ setup_requirements = []
 
 test_requirements = [
     "pytest==6.1.2",
-    "responses==0.12.0"
+    "responses==0.12.1"
 ]
 
 setup(
@@ -50,6 +50,6 @@ setup(
     test_suite='tests',
     tests_require=test_requirements,
     url='https://github.com/eeriks/erepublik/',
-    version='0.22.3.1',
+    version='0.23.2',
     zip_safe=False,
 )