battlefield-term 0.1.20__tar.gz

battlefield_term-0.1.20/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.1
+Name: battlefield_term
+Version: 0.1.20
+Summary: battlefield terminal game
+Home-page: 
+Author: Jarmil Halamicek
+Author-email: hi@jarmil.com
+License: BSD 2-clause
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Topic :: Games/Entertainment :: Simulation
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.12

battlefield_term-0.1.20/README.md

@@ -0,0 +1,128 @@
+# Bot battlefield game
+
+derived from tg/pilot
+
+    
+## Geometrie na scene 
+
+Vse se meri v metrech.
+X je zleva doprava, Y je zdola nahoru.
+Sever je nahore (tedy kladne hodnoty Y), vychod vpravo (kladne hodnoty X)
+Rotace je clockwise: 0 stupnu sever, 90 vychod, 180 jih, 270 zapad 
+
+
+## Tech stack
+
+Python 3.10 (python 3.12 je nekompatibilni se starsim numpy verze < 2)
+
+
+## Netridene todos a improvements
+
+- IMP keyup - keydown logic v Keyboard
+- IMP: Scene: zadej uvodni zvetseni
+- IMP: ovladani WASD a Tab atd aktivni i kdyz je otevrene submenu
+- IMP: move to wheel package (binary)
+- 
+
+## Marketing
+
+“Deploy and command combat drones—set their tactics, position them on the battlefield, 
+and manage the economy so your operations stay in control.”
+
+## Summary (pro šéfa marketingu)
+Cíl je dostat zcela nový Steam účet (0 wishlistů) do režimu růstu během 3 měsíců pomocí konzistentního outreachu a hlavně konzistentních Steam update postů/patch notes pro alpha verzi. Hra je singleplayer, 3rd person/aerial-map view a primární “hook” jsou autonomní bojové drony; diferenciátor je kombinace velení strategie dronů + hlídání ekonomiky/tempa operací. Priorita: rychle vybudovat důvěru (důkazy v běžících featurech a opravách), vyvolat návštěvy stránky a konverzi na wishlist přes jasné “co testovat teď”.
+
+## Přehled strategie (co děláme)
+- Steam stránka jako “alpha-grade” přesvědčivý brief: trailer (60–90 s), 6–10 screenshotů, About This Game (jasně co je funkční v alfě), “What’s Next” na 4–6 týdnů dopředu, přesné tagy.
+- Komunita a feedback loop: Steam Community/Discussions rozdělené na typy feedbacku + konzistentní patch notes s “known issues” a “what to test next”.
+- Outreach na míru targeting matrix:
+  1) command/tactics (3rd-person rozhodování),
+  2) autonomous units/squad AI (sledování chování AI),
+  3) economy/tempo (scaling/balance),
+  4) aerial/cinematic drone gameplay (wow deploy moments),
+  5) singleplayer systems (depth bez co-op).
+- Outreach: ne spam; osobní DM/komentáře s jasným “why you” a konkrétním call to action (Steam page + access + checklist testů + deadline pro feedback).
+- Update tempo: ideálně 1 update týdně (nebo 1× za 7–14 dní), ale vždy ve stejném formátu a s vazbou na feedback.
+
+## Cíle (3 měsíce)
+- Vybudovat první traction na Steam: wishlistů a aktivních hráčů v alfě především díky konzistenci update obsahu a důkazům.
+- Vytvořit “důvěryhodný rytmus” (hráči očekávají patch notes a vědí, co testovat).
+- Získat stabilní tok kvalitního feedbacku zaměřeného na autonomní drony (strategie), ekonomiku (tempo/failure states) a největší frikce (onboarding/performance/AI edge cases).
+
+## Taktické kroky – 3 měsíce po týdnech
+
+### Měsíc 1 (Týdny 1–4): Launch alfa signálu + první důkaz
+**Týden 1**
+- Zveřejnit Steam stránku v kvalitě “alpha-grade”: 1 krátký trailer, 6–10 screenshotů, jasné About This Game, “What’s Next” (4–6 týdnů), tagy odpovídající: military/realistic/tactics/vehicles dle relevance.
+- Vytvořit Steam Community strukturu: Discussions k tématům (bugs, balance & tactics, performance, suggestions).
+- První outreach dávka: top 15 cílených kontaktů (tactics/command + autonomous AI).
+  - Poslat: Steam page + alpha access (jak máte) + checklist “co otestovat” do 3–5 dní.
+
+**Týden 2**
+- První komunitní “Alpha Welcome / Dev Update”: co funguje, co je známé riziko, co testovat příští týden.
+- Patch notes k prvním změnám: “what changed”, “known issues”, “what to test next”.
+- Outreach follow-up jen pro ty, kdo reagovali/otevřeli DM (1 krátká zpráva).
+
+**Týden 3**
+- Druhý outreach vlnou segmenty 3 (economy/tempo) + 4 (aerial/cinematic).
+- Dev post: 3 konkrétní learnings z feedbacku + 3 věci do dalšího buildu.
+- Upřesnit Steam stránku podle aktuálních odpovědí komunity (zejména About / What’s Next).
+
+**Týden 4**
+- “Alpha Hot Fix + Roadmap Window” post: co jste opravili a na čem se teď soustředíte (na dalších 2–3 týdny).
+- Spustit režim sběru feedbacku: vždy checklist + deadline pro test (zrychlí iterace a zvýší návratnost).
+
+---
+
+### Měsíc 2 (Týdny 5–8): Růst díky konzistenci update rytmu
+**Týden 5**
+- 1. pravidelný týdenní update (nebo 2týdenní podle kapacity) ve stejném formátu:
+  - What’s new (max 5)
+  - What changed based on feedback (min 2)
+  - Known issues (max 3)
+  - What to test next (konkrétní testy na drony + ekonomiku)
+- Outreach: segment 1 a 2 (tactics/command + autonomous AI) – rozšířit na 25–40 kontaktů celkem v tomto měsíci.
+
+**Týden 6**
+- Zaměřený outreach na segment 2: “autonomous units behavior tests” (poslat 3 testy: priority cíle, chování pod tlakem, degradace při špatné ekonomice/tempu).
+- Komunitní post s “Top 3 takeaways for players” (krátce, lidsky).
+
+**Týden 7**
+- Update zaměřený na největší frikci, která se objevuje ve feedbacku (např. AI volba, target priority, pathing/spotting, performance).
+- Uvést v patch notes i “why” (co z feedbacku spustilo změnu).
+
+**Týden 8**
+- Second mid-cycle post: “Feature spotlight” (jeden systém/loop) + výslovně “tohle prosím testujte v příštím buildu”.
+- Outreach: segment 3 (economy/tempo) + 4 (aerial/cinematic) – nabídnout konkrétní “deploy + tempo” scénáře.
+
+---
+
+### Měsíc 3 (Týdny 9–12): Milník, jasná hodnota, event/boost důvěry
+**Týden 9**
+- Velký milníkový update (marketingově silný): zlepšení “core” části smyčky—autonomní drony + rozhodování strategie (taktika) + ekonomický failure/success model.
+- Steam stránka: doplnit “Getting Started” (5 kroků) a vylepšit “What’s Next” podle aktuální reality.
+
+**Týden 10**
+- Outreach: re-hit pro top tvůrce/komunity, které reagovaly nejlépe (ne pro všechny).
+- Komunitní post: “Before/After” (staré vs nové chování dronů / ekonomiky / tempo výsledků).
+
+**Týden 11**
+- Krátká event akce na 3–5 dní v komunitě:
+  - “Alpha Tactics Challenge” (týdenní tematický cíl: např. test 2 různých drone tactics + report kdy ekonomika začne degradovat operace)
+  - Vyžadovat krátký formát feedbacku (co se stalo / co jste změnili / screenshot/video pokud jde).
+
+**Týden 12**
+- Závěrečný “Alpha Cycle Review” post:
+  - co jsme získali od hráčů,
+  - co je hotovo,
+  - co je další milník (další roadmap window),
+  - přímý call: “wishlist if you want to continue shaping the next cycle” (bez PR mlhy).
+- Připravit další fázi komunikace (navázat na to, co vyšlo v měsíci 3: jaké claimy jsou podložené reálnými reakcemi).
+
+## Outreach: operativní pravidla (aby to fungovalo)
+- Každému kontaktu: osobní “why you” (navázat na jejich témata), konkrétní testy (3–5 bodů), jasný access + deadline.
+- Rytmus: 2 outreach vlny v měsíci 1, 3–4 vlny v měsíci 2, re-hit top segmenty v měsíci 3.
+- Kanály: YouTube/Twitch (tactics/milsim/AI/vehicles), Discordy tactical/realism komunity, Reddit/threads v tématech realism/tactics, menší “indie milsim” discovery.
+- Očekávaný výstup od testerů: mini-reports + 1–2 videa/screens (pokud možná), jinak aspoň reprodukce problému a co vedlo ke změně.
+
+Chceš, abych dodal i 3–4 konkrétní šablony anglických DM zpráv (pro segmenty 1–3) a anglický formát patch notes postu, které pak jen doplňujete konkrétními body z buildu?

battlefield_term-0.1.20/battlefield_term.egg-info/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.1
+Name: battlefield-term
+Version: 0.1.20
+Summary: battlefield terminal game
+Home-page: 
+Author: Jarmil Halamicek
+Author-email: hi@jarmil.com
+License: BSD 2-clause
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Topic :: Games/Entertainment :: Simulation
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.12

battlefield_term-0.1.20/battlefield_term.egg-info/SOURCES.txt

@@ -0,0 +1,88 @@
+README.md
+setup.py
+battlefield_term.egg-info/PKG-INFO
+battlefield_term.egg-info/SOURCES.txt
+battlefield_term.egg-info/dependency_links.txt
+battlefield_term.egg-info/entry_points.txt
+battlefield_term.egg-info/requires.txt
+battlefield_term.egg-info/top_level.txt
+src/__init__.py
+src/base.py
+src/driver.py
+src/func.py
+src/game.py
+src/helpers.py
+src/historicalposition.py
+src/main.py
+src/mixins.py
+src/settings.py
+src/singletons.py
+src/chassis/__init__.py
+src/chassis/chassis.py
+src/chassis/simple_chassis.py
+src/geometry/__init__.py
+src/geometry/euclid.py
+src/geometry/position.py
+src/geometry/triangle.py
+src/modes/__init__.py
+src/modes/helpers.py
+src/modes/none.py
+src/modes/roam_and_destroy.py
+src/modes/rotation.py
+src/modes/spiral.py
+src/modes/straight.py
+src/modes/to_homebase.py
+src/modes/to_position.py
+src/modes/turns.py
+src/modes/waypoints.py
+src/paths/__init__.py
+src/paths/area.py
+src/paths/path.py
+src/paths/point_collection.py
+src/paths/waypoint.py
+src/rovers/__init__.py
+src/rovers/rover.py
+src/rovers/tracked.py
+src/scene/__init__.py
+src/scene/scene.py
+src/scene/objects/__init__.py
+src/scene/objects/borderstone.py
+src/scene/objects/damageable.py
+src/scene/objects/rectangle.py
+src/scene/objects/scene_object.py
+src/scene/objects/tree.py
+src/scene/objects/triangle.py
+src/snd/detonation.wav
+src/snd/spawned_enemy.wav
+src/snd/spawned_own.flac
+src/ux/__init__.py
+src/ux/cycler.py
+src/ux/functions.py
+src/ux/graph.py
+src/ux/grid.py
+src/ux/groups.py
+src/ux/helpers.py
+src/ux/images.py
+src/ux/keyboard.py
+src/ux/map_display.py
+src/ux/menu.py
+src/ux/screen.py
+src/ux/statusbar.py
+src/ux/switches.py
+src/ux/texts.py
+src/ux/ux.py
+src/ux/dialogs/__init__.py
+src/ux/dialogs/dialog.py
+src/ux/dialogs/waypoints.py
+src/ux/submenus/__init__.py
+src/ux/submenus/driver.py
+src/ux/submenus/help.py
+src/ux/submenus/map.py
+src/ux/submenus/rover.py
+src/ux/submenus/scene.py
+src/ux/submenus/spawn.py
+src/ux/submenus/submenu.py
+src/ux/triggers/__init__.py
+src/ux/triggers/driver_mode_trigger.py
+src/ux/triggers/submenu_trigger.py
+src/ux/triggers/trigger.py

battlefield_term-0.1.20/battlefield_term.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

battlefield_term-0.1.20/battlefield_term.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+battlefield_term = battlefield_term.main:main

battlefield_term-0.1.20/battlefield_term.egg-info/requires.txt

@@ -0,0 +1,6 @@
+pygame>=2.5.0
+Pillow>=10.0.0
+PyYAML>=6.0.1
+arrow>=1.3.0
+numpy>=1.24.3
+termcolor>=2.4.0

battlefield_term-0.1.20/battlefield_term.egg-info/top_level.txt

@@ -0,0 +1 @@
+battlefield_term

battlefield_term-0.1.20/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

battlefield_term-0.1.20/setup.py

@@ -0,0 +1,53 @@
+from setuptools import setup
+from src import version
+
+setup(
+    name='battlefield_term',
+    version=version,
+    description='battlefield terminal game',
+    url='',
+    author='Jarmil Halamicek',
+    author_email='hi@jarmil.com',
+    license='BSD 2-clause',
+    package_dir={'battlefield_term': 'src'},
+    packages=[
+        'battlefield_term',
+        'battlefield_term.chassis',
+        'battlefield_term.geometry',
+        'battlefield_term.modes',
+        'battlefield_term.paths',
+        'battlefield_term.rovers',
+        'battlefield_term.scene',
+        'battlefield_term.scene.objects',
+        'battlefield_term.ux',
+        'battlefield_term.ux.dialogs',
+        'battlefield_term.ux.submenus',
+        'battlefield_term.ux.triggers',
+    ],
+    install_requires=[
+        'pygame>=2.5.0',
+        'Pillow>=10.0.0',
+        'PyYAML>=6.0.1',
+        'arrow>=1.3.0',
+        'numpy>=1.24.3',
+        'termcolor>=2.4.0',
+    ],
+    classifiers=[
+        'Development Status :: 3 - Alpha',
+        'Intended Audience :: End Users/Desktop',
+        'License :: OSI Approved :: BSD License',
+        'Topic :: Games/Entertainment :: Simulation',
+        'Operating System :: POSIX :: Linux',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.12',
+    ],
+
+    package_data={'battlefield_term': ['snd/*']},
+    entry_points={
+        'console_scripts': [
+            'battlefield_term=battlefield_term.main:main',
+        ],
+    },
+)

battlefield_term-0.1.20/src/__init__.py

@@ -0,0 +1,2 @@
+
+version = "0.1.20"

battlefield_term-0.1.20/src/base.py

@@ -0,0 +1,63 @@
+import random
+import time
+
+from .geometry.position import Position
+from .helpers import Angle
+from .rovers.tracked import DronePiggy, DroneTango, DroneViper
+from .modes.roam_and_destroy import RoamAndDestroy
+from .scene.objects.damageable import DamageableObject
+
+
+class ArmyBase(DamageableObject):
+
+    max_damage = 20000
+    enemy = None
+    seen_forever = True
+
+    def __init__(self, scene, x, y):
+        super().__init__(Position(x, y, Angle(360-scene.orientation).value))
+        self.scene = scene
+
+    def spawn_drone(self, drone_class):
+        if self.alive:
+            rover = drone_class(Position(self.position.x, self.position.y, random.randint(0, 359)), f"#{self.scene.drone_index}", self.scene, self.enemy)
+            rover.driver.set_mode(RoamAndDestroy)
+            self.scene.add_rover(rover)
+            self.scene.game.status_bar.warning = f"Drone {rover} spawned by {'enemy' if self.enemy else 'us'}"
+
+
+class HomeBase(ArmyBase):
+    color = "blue"
+    name = "Home base"
+    enemy = False
+
+    def spawn_drone(self, drone_class):
+        """ Vypusti bota a strhne si za to penize """
+        if drone_class.price > self.scene.game.score:
+            # IMP: should raise exception and trigger catches and displays it
+            self.scene.game.status_bar.warning = f"Drone costs {drone_class.price}, you have only {self.scene.game.score}"
+            return
+        self.scene.game.score -= drone_class.price
+        self.scene.game.play_sound("spawned_own.flac")
+
+        return super().spawn_drone(drone_class)
+
+
+class EnemyBase(ArmyBase):
+    color = "red"
+    name = "Enemy base"
+    enemy = True
+    spawn_interval = 40  # in seconds
+
+    def __init__(self, scene, x, y):
+        super().__init__(scene, x, y)
+        self.spawn_start = time.time()
+
+    def spawn_rover(self):
+        self.spawn_drone(random.choice([DroneViper, DroneViper, DronePiggy, DroneTango]))
+        self.scene.game.play_sound("spawned_enemy.wav")
+
+    def do(self):
+        if time.time() - self.spawn_start > self.spawn_interval:
+            self.spawn_rover()
+            self.spawn_start = time.time()

battlefield_term-0.1.20/src/chassis/chassis.py

@@ -0,0 +1,20 @@
+from ..geometry.euclid import EuclideanObject
+
+
+class Chassis(EuclideanObject):
+    """ common ancestor for all chassis """
+
+    color =  [128, 240, 180]
+
+    def __init__(self, rover, position):
+        super().__init__(position)
+        self.rover = rover
+
+    @property
+    def speed(self):
+        return 0
+
+    def update(self, time_elapsed):
+        pass
+
+

battlefield_term-0.1.20/src/chassis/simple_chassis.py

@@ -0,0 +1,152 @@
+import math
+import pygame
+from pygame import Vector2
+
+from .chassis import Chassis
+
+
+class SimpleChassis(Chassis):
+    """ Jednoduche chassis co umi zatacet """
+
+    max_speed = 10  # m/s
+    speed_change_step = 2.5
+    max_rotation_speed = 12  # degrees/s
+    rotation_speed_change_step = 4
+
+    def __init__(self, rover, position):
+        super().__init__(rover, position)
+        self._speed = 0
+        self._rotation_speed = 0
+
+    def __str__(self):
+        return f"Simple chassis {self.speed} m/s"
+
+    def draw_body(self, ux_object, rover_position):
+        super().draw_body(ux_object, rover_position)
+        my_rover_position = ux_object.screen.translate_position_to_screen(self.position.vector2-rover_position.vector2)
+        angle = 360 - self.position.angle   # kresli se do sceny inverted
+
+        self.draw_track(ux_object.screen.pygame_screen, my_rover_position, angle)
+
+    def draw_track(self, screen, position, direction):
+        """Draws speed indicator at given position"""
+        max_area = 50
+        width, length = 6, 30
+        real_pos = Vector2(position)
+
+        # Create transparent surface for rotating indicator
+        s = pygame.Surface((max_area, max_area))
+        s = s.convert_alpha()
+        s.fill((0, 0, 0, 0))
+
+        # Draw it to the surface
+        pygame.draw.rect(
+            s,
+            (60, 60, 60),
+            pygame.Rect(
+                (max_area - width) / 2,
+                (max_area - length) / 2,
+                width,
+                length,
+            ),
+        )
+        if self.speed_percentage > 0:
+            pygame.draw.rect(
+                s,
+                "green",
+                pygame.Rect(
+                    (max_area - width) / 2 ,
+                    (max_area - length) / 2,
+                    width,
+                    self.speed_percentage * length,
+                ),
+            )
+        else:
+            pygame.draw.rect(
+                s,
+                "red",
+                pygame.Rect(
+                    (max_area - width) / 2,
+                    (max_area - length) / 2,
+                    width,
+                    -self.speed_percentage * length,
+                ),
+            )
+
+        # And rotate it
+        s = pygame.transform.rotate(s, direction)
+        screen.blit(s, real_pos - Vector2(s.get_size()) / 2)
+
+    @property
+    def speed(self):
+        return self._speed if self.rover.alive else 0
+
+    @speed.setter
+    def speed(self, value):
+        if -self.max_speed <= value <= self.max_speed:
+            self._speed = value
+
+    @property
+    def rotation_speed(self):
+        """ Uhlova rychlost v stupnich za sekundu """
+        return self._rotation_speed if self.rover.alive else 0
+
+    @rotation_speed.setter
+    def rotation_speed(self, value):
+        if - self.max_rotation_speed <= value <= self.max_rotation_speed:
+            self._rotation_speed = value
+
+    @property
+    def speed_percentage(self):
+        return self.speed / self.max_speed
+
+    def update(self, time_elapsed):
+        """Periodically called to update rover position and other attributes"""
+        distance_driven = self.speed * time_elapsed
+        angle = 360 - self.position.angle + 90
+        angle = math.radians(angle)
+        x_offset = distance_driven * math.cos(angle)
+        y_offset = -distance_driven * math.sin(angle)
+        self.position.x += x_offset
+        self.position.y -= y_offset
+        self.position.angle += self.rotation_speed * time_elapsed
+
+    def stop(self):
+        self.speed = 0
+        self.rotation_speed = 0
+
+    def at_arrow_up(self):
+        self.speed += self.speed_change_step
+
+    def at_arrow_down(self):
+        self.speed -= self.speed_change_step
+
+    def at_arrow_left(self):
+        self.steer_left()
+
+    def at_arrow_right(self):
+        self.steer_right()
+
+    def steer_left(self):
+        self.rotation_speed -= self.rotation_speed_change_step
+
+    def steer_right(self):
+        self.rotation_speed += self.rotation_speed_change_step
+
+    def set_speed_as_percentage(self, percentage):
+        self.speed = percentage * self.max_speed
+
+
+class FastSimpleChassis(SimpleChassis):
+    max_speed = 15 # m/s
+    speed_change_step = max_speed / 4
+
+
+class SuperFastSimpleChassis(SimpleChassis):
+    max_speed = 36 # m/s
+    speed_change_step = max_speed / 4
+
+
+class HeavySimpleChassis(SimpleChassis):
+    max_speed = 2  # m/s
+    speed_change_step = .5

battlefield_term-0.1.20/src/driver.py

@@ -0,0 +1,56 @@
+""" Driver is a rover controller capable of working in some of predefined modes """
+from .modes.none import ModeNone
+
+
+class Driver:
+
+    color = "white"
+
+    def __init__(self, rover):
+        self.rover = rover
+        self.mode_object = None
+        self.set_mode(ModeNone)
+
+        # HACK: properties used by some modes. We have no mechanism to set mode "parameters"
+        self.mode_waypoints_loop = None
+
+    def set_mode(self, mode):
+        self.mode_object = mode(self)
+        self.rover.scene.game.status_bar.message = f"{self.rover} is in mode {str(self.mode_object)}"
+
+    def draw(self, ux, position):
+        try:
+            self.mode_object.draw(ux, position)
+        except AttributeError:
+            pass
+
+    def do(self):
+        """ Work done on each loop: just calling the command if exists.
+            Due to fact that command is called multiple times (say 10x/sec), every command
+            method should check the state, make adjustments and return control.
+        """
+        if self.rover.alive:
+
+            if self.mode_object:
+
+                # auto-detonate mod. Detekuj blizke objekty a pokud je to vyhodne, exploduj
+                # pouze kdyz bot je ovladany ridicem, aby nedetonoval rucne
+                objects = self.rover.get_nearby_damageable_objects()
+                if objects:
+                    foes = [x for x in objects if x.is_foe(self.rover)]
+                    friends = [x for x in objects if not x.is_foe(self.rover)]   # includes neutrals
+
+                    foe_damage = sum([x.get_expected_damage(self.rover, self.rover.detonation_damage) for x in foes])
+                    friend_damage = sum([x.get_expected_damage(self.rover, self.rover.detonation_damage) for x in friends])
+                    score = foe_damage + friend_damage - friend_damage
+
+                    if score > self.rover.price:
+                        self.rover.detonate()
+
+                if not self.rover.alive:
+                    return
+
+                self.mode_object.wrapped_do()
+                if self.mode_object.finished:
+                    self.set_mode(ModeNone)
+                    self.rover.stop()

battlefield_term-0.1.20/src/func.py

@@ -0,0 +1,18 @@
+import json
+
+from . import settings
+
+
+def load_status_file():
+    try:
+        with open(settings.STATUS_FILE, "r") as f:
+            return json.load(f)
+    except FileNotFoundError:
+        return {}
+
+
+def save_status_file(data):
+    data["_info"] = "This file contains saved status of battlefield_term game"
+    with open(settings.STATUS_FILE, "w") as f:
+        f.write(json.dumps(data, indent=4))
+