bcsfe 3.2.0b3__tar.gz → 3.2.1__tar.gz

{bcsfe-3.2.0b3/src/bcsfe.egg-info → bcsfe-3.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bcsfe
-Version: 3.2.0b3
+Version: 3.2.1
 Summary: A save file editor for The Battle Cats
 Author: fieryhenry
 License-Expression: GPL-3.0-or-later
@@ -298,13 +298,16 @@ pip uninstall bcsfe
 ```
 ## Terms of Use
 
+I don't like that I have to have Terms of use but these terms are designed to prevent scams and the
+exploitation of users.
+
 By using the editor you agree to the following:
 
 If you are using the editor to run a paid service that profits off of the editor
 (e.g a service to provide people with hacked accounts, or a paid discord bot to edit people's accounts,
 etc) you must make it very clear that you are using this save editor.
 
-This should be done by linking this GitHub page, and explicitly stating that the tool you are
+This should be done by linking this Codeberg page, and explicitly stating that the tool you are
 using is available for free and that they don't need to use your service to hack their account.
 
 This information needs to be visible and something the customer agrees to **before** any payment is made.
@@ -318,8 +321,6 @@ the editor under the hood as long as you abide by the [License](#license). Basic
 distributing a program which uses the editor, you need to license your own program under the GPL
 or a compatible license (basically make it open source / free software too).
 
-These terms are designed to prevent scams and the exploitation of users.
-
 Also if you **are** profiting from the editor, it would be greatly appreciated if you could
 give back something and support me.
 
@@ -429,13 +430,13 @@ You'll need to collect the catfood in-game after each clear though
 
 ### Install from source
 
-If you want the latest features then you can install the editor from the github.
+If you want the latest features then you can install the editor from the git repo.
 
 1. Download git:
-    1. Windows: [Git](https://git-scm.com/downloads)
-    2. Linux: (use package manager, e.g `sudo apt-get install git` or `sudo pacman -S git`)
-    3. Android: Termux: `pkg install git`
-    4. iOS: a-Shell should already include it
+    - Windows: [Git](https://git-scm.com/downloads)
+    - Linux: (use package manager, e.g `sudo apt-get install git` or `sudo pacman -S git`)
+    - Android: Termux: `pkg install git`
+    - iOS: a-Shell should already include it
 
 2. Run the following commands: (You may have to replace `py` with `python` or `python3`)
 

{bcsfe-3.2.0b3 → bcsfe-3.2.1}/README.md

@@ -269,13 +269,16 @@ pip uninstall bcsfe
 ```
 ## Terms of Use
 
+I don't like that I have to have Terms of use but these terms are designed to prevent scams and the
+exploitation of users.
+
 By using the editor you agree to the following:
 
 If you are using the editor to run a paid service that profits off of the editor
 (e.g a service to provide people with hacked accounts, or a paid discord bot to edit people's accounts,
 etc) you must make it very clear that you are using this save editor.
 
-This should be done by linking this GitHub page, and explicitly stating that the tool you are
+This should be done by linking this Codeberg page, and explicitly stating that the tool you are
 using is available for free and that they don't need to use your service to hack their account.
 
 This information needs to be visible and something the customer agrees to **before** any payment is made.
@@ -289,8 +292,6 @@ the editor under the hood as long as you abide by the [License](#license). Basic
 distributing a program which uses the editor, you need to license your own program under the GPL
 or a compatible license (basically make it open source / free software too).
 
-These terms are designed to prevent scams and the exploitation of users.
-
 Also if you **are** profiting from the editor, it would be greatly appreciated if you could
 give back something and support me.
 
@@ -400,13 +401,13 @@ You'll need to collect the catfood in-game after each clear though
 
 ### Install from source
 
-If you want the latest features then you can install the editor from the github.
+If you want the latest features then you can install the editor from the git repo.
 
 1. Download git:
-    1. Windows: [Git](https://git-scm.com/downloads)
-    2. Linux: (use package manager, e.g `sudo apt-get install git` or `sudo pacman -S git`)
-    3. Android: Termux: `pkg install git`
-    4. iOS: a-Shell should already include it
+    - Windows: [Git](https://git-scm.com/downloads)
+    - Linux: (use package manager, e.g `sudo apt-get install git` or `sudo pacman -S git`)
+    - Android: Termux: `pkg install git`
+    - iOS: a-Shell should already include it
 
 2. Run the following commands: (You may have to replace `py` with `python` or `python3`)
 

{bcsfe-3.2.0b3 → bcsfe-3.2.1}/src/bcsfe/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "3.2.0b3"
+__version__ = "3.2.1"
 
 from bcsfe import core, cli
 

{bcsfe-3.2.0b3 → bcsfe-3.2.1}/src/bcsfe/cli/dialog_creator.py

@@ -150,7 +150,7 @@ class ListOutput:
     def __init__(
         self,
         strings: list[str],
-        ints: list[int],
+        ints: list[int] | list[str],
         dialog: str | None = None,
         perameters: dict[str, Any] | None = None,
         start_index: int = 1,
@@ -210,7 +210,7 @@ class ChoiceInput:
         self,
         items: list[str],
         strings: list[str],
-        ints: list[int],
+        ints: list[int] | list[str],
         perameters: dict[str, int | str],
         dialog: str,
         single_choice: bool = False,
@@ -233,7 +233,7 @@ class ChoiceInput:
     @staticmethod
     def from_reduced(
         items: list[str],
-        ints: list[int] | None = None,
+        ints: list[int] | list[str] | None = None,
         perameters: dict[str, int | str] | None = None,
         dialog: str | None = None,
         single_choice: bool = False,
@@ -482,7 +482,7 @@ class MultiEditor:
         choices, all_at_once = ChoiceInput(
             self.items,
             self.strings,
-            self.ints or [],
+            self.ints or [],  # type: ignore
             self.perameters,
             "select_edit",
         ).get()
@@ -588,9 +588,7 @@ class SingleEditor:
         self.signed = signed
 
     def edit(self, escape_text: bool = True) -> int:
-        max_value = self.max_value
-        if max_value is None:
-            max_value = IntInput.get_max_value(max_value, self.signed)
+        max_value = IntInput.get_max_value(self.max_value, self.signed)
         if self.max_value is None:
             dialog = "input_non_max"
         elif self.min_value != 0:

{bcsfe-3.2.0b3 → bcsfe-3.2.1}/src/bcsfe/cli/edits/basic_items.py

@@ -165,6 +165,8 @@ class BasicItems:
             core.core_data.max_value_manager.get("platinum_tickets")
             - platinum_ticket_amount
         ) * 10 + 9
+
+        max_value = max(0, max_value)
         save_file.platinum_shards = dialog_creator.SingleEditor(
             BasicItems.get_name(name, "platinum_shards"),
             save_file.platinum_shards,
@@ -193,6 +195,10 @@ class BasicItems:
     def edit_battle_items(save_file: core.SaveFile):
         save_file.battle_items.edit(save_file)
 
+    @staticmethod
+    def edit_battle_items_endless(save_file: core.SaveFile):
+        save_file.battle_items.edit_endless_items(save_file)
+
     @staticmethod
     def edit_catamins(save_file: core.SaveFile):
         names_o = core.core_data.get_gatya_item_names(save_file)
@@ -249,7 +255,7 @@ class BasicItems:
         if items is None:
             return
         names: list[str] = []
-        for item in items:
+        for item in items[: len(save_file.treasure_chests)]:
             name = names_o.get_name(item.id)
             if name is None:
                 name = core.core_data.local_manager.get_key(

{bcsfe-3.2.0b3 → bcsfe-3.2.1}/src/bcsfe/cli/edits/map.py

@@ -12,6 +12,12 @@ ChaptersType = Union[
 ]
 
 
+def get_total_maps(chapters: ChaptersType) -> int:
+    if isinstance(chapters, core.EventChapters):
+        return chapters.get_lengths()[1]
+    return len(chapters.chapters)
+
+
 def unclear_stage(
     chapters: ChaptersType,
     map: int,
@@ -98,7 +104,11 @@ def edit_chapters(
     map_names = core.MapNames(
         save_file, letter_code, no_r_prefix=no_r_prefix, base_index=base_index
     )
-    names = map_names.map_names
+    names: dict[int, str | None] = {}
+    for id, name in map_names.map_names.items():
+        if id >= get_total_maps(chapters):
+            continue
+        names[id] = name
 
     choice = dialog_creator.ChoiceInput.from_reduced(
         ["clear_stages", "unclear_stages"],

{bcsfe-3.2.0b3 → bcsfe-3.2.1}/src/bcsfe/cli/feature_handler.py

@@ -58,6 +58,7 @@ class FeatureHandler:
                 "np": edits.basic_items.BasicItems.edit_np,
                 "leadership": edits.basic_items.BasicItems.edit_leadership,
                 "battle_items": edits.basic_items.BasicItems.edit_battle_items,
+                "battle_items_endless": edits.basic_items.BasicItems.edit_battle_items_endless,
                 "catseyes": edits.basic_items.BasicItems.edit_catseyes,
                 "catfruit": edits.basic_items.BasicItems.edit_catfruit,
                 "talent_orbs": core.game.catbase.talent_orbs.SaveOrbs.edit_talent_orbs,

bcsfe-3.2.1/src/bcsfe/core/game/battle/battle_items.py

@@ -0,0 +1,297 @@
+from __future__ import annotations
+
+import datetime
+from math import inf
+from typing import Any
+from bcsfe import core
+from bcsfe.cli import dialog_creator, color
+
+
+class EndlessItem:
+    def __init__(
+        self, active: bool, unknown: bool, amount: int, start: float, end: float
+    ):
+        self.active = active
+        self.unknown = unknown
+        self.amount = amount
+        self.start = start
+        self.end = end
+
+    @staticmethod
+    def init() -> EndlessItem:
+        return EndlessItem(False, False, 0, 0, 0)
+
+    @staticmethod
+    def read(stream: core.Data) -> EndlessItem:
+        return EndlessItem(
+            stream.read_bool(),
+            stream.read_bool(),
+            stream.read_byte(),
+            stream.read_double(),
+            stream.read_double(),
+        )
+
+    def write(self, stream: core.Data):
+        stream.write_bool(self.active)
+        stream.write_bool(self.unknown)
+        stream.write_byte(self.amount)
+        stream.write_double(self.start)
+        stream.write_double(self.end)
+
+    def serialize(self) -> dict[str, Any]:
+        return {
+            "active": self.active,
+            "unknown": self.unknown,
+            "amount": self.amount,
+            "start": self.start,
+            "end": self.end,
+        }
+
+    @staticmethod
+    def deserialize(data: dict[str, Any]) -> EndlessItem:
+        return EndlessItem(
+            data.get("active", False),
+            data.get("unknown", False),
+            data.get("amount", 0),
+            data.get("start", 0.0),
+            data.get("end", 0.0),
+        )
+
+    def get_endless_duration(self) -> datetime.timedelta | None:
+        if not self.active:
+            return datetime.timedelta()
+
+        if self.end == inf:
+            return None
+
+        return datetime.timedelta(
+            seconds=self.end - self.start + (self.amount * 3 * 60 * 60)
+        )
+
+    def get_endless_duration_formatted(self) -> str:
+        duration = self.get_endless_duration()
+
+        if duration is None:
+            return core.localize("infinity_duration")
+
+        days = duration.days
+        hours, rem = divmod(duration.seconds, 3600)
+        minutes, seconds = divmod(rem, 60)
+
+        return core.localize(
+            "duration", days=days, hours=hours, minutes=minutes, seconds=seconds
+        )
+
+    def set_duration_mins(self, mins: float, amount: int):
+        self.active = True
+        self.unknown = True
+        self.amount = amount
+        self.start = datetime.datetime.now(datetime.timezone.utc).timestamp()
+        self.end = self.start + mins * 60
+
+
+class BattleItem:
+    def __init__(self, amount: int):
+        self.amount = amount
+        self.locked = False
+
+        self.endless_item = EndlessItem.init()
+
+    @staticmethod
+    def init() -> BattleItem:
+        return BattleItem(0)
+
+    @staticmethod
+    def read_amount(stream: core.Data) -> BattleItem:
+        return BattleItem(stream.read_int())
+
+    def write_amount(self, stream: core.Data):
+        stream.write_int(self.amount)
+
+    def read_locked(self, stream: core.Data):
+        self.locked = stream.read_bool()
+
+    def write_locked(self, stream: core.Data):
+        stream.write_bool(self.locked)
+
+    def read_endless_items(self, stream: core.Data):
+        self.endless_item = EndlessItem.read(stream)
+
+    def write_endless_items(self, stream: core.Data):
+        self.endless_item.write(stream)
+
+    def serialize(self) -> dict[str, Any]:
+        return {
+            "amount": self.amount,
+            "locked": self.locked,
+            "endless": self.endless_item.serialize(),
+        }
+
+    @staticmethod
+    def deserialize(data: dict[str, Any]) -> BattleItem:
+        battle_item = BattleItem(data.get("amount", 0))
+        battle_item.locked = data.get("locked", False)
+        battle_item.endless_item = EndlessItem.deserialize(data.get("endless", {}))
+        return battle_item
+
+    def __repr__(self):
+        try:
+            return f"BattleItem({self.amount}, {self.locked}, {self.endless_item})"
+        except AttributeError:
+            return f"BattleItem({self.amount}, {self.endless_item})"
+
+    def __str__(self):
+        return self.__repr__()
+
+
+class BattleItems:
+    def __init__(self, items: list[BattleItem]):
+        self.items = items
+        self.lock_item = False
+
+    @staticmethod
+    def init() -> BattleItems:
+        return BattleItems([BattleItem.init() for _ in range(6)])
+
+    @staticmethod
+    def read_items(stream: core.Data) -> BattleItems:
+        total_items = 6
+        items = [BattleItem.read_amount(stream) for _ in range(total_items)]
+        return BattleItems(items)
+
+    def write_items(self, stream: core.Data):
+        for item in self.items:
+            item.write_amount(stream)
+
+    def read_locked_items(self, stream: core.Data):
+        self.lock_item = stream.read_bool()
+        for item in self.items:
+            item.read_locked(stream)
+
+    def write_locked_items(self, stream: core.Data):
+        stream.write_bool(self.lock_item)
+        for item in self.items:
+            item.write_locked(stream)
+
+    def read_endless_items(self, stream: core.Data):
+        for i in range(6):
+            if i >= len(self.items):
+                _ = EndlessItem.read(stream)  # ensure we still read 6 items
+            else:
+                item = self.items[i]
+                item.read_endless_items(stream)
+
+    def write_endless_items(self, stream: core.Data):
+        for i in range(6):
+            if i >= len(self.items):
+                EndlessItem.init().write(stream)  # ensure we still write 6 items
+            else:
+                item = self.items[i]
+                item.write_endless_items(stream)
+
+    def serialize(self) -> dict[str, Any]:
+        return {
+            "items": [item.serialize() for item in self.items],
+            "lock_item": self.lock_item,
+        }
+
+    @staticmethod
+    def deserialize(data: dict[str, Any]) -> BattleItems:
+        battle_items = BattleItems(
+            [BattleItem.deserialize(item) for item in data.get("items", [])]
+        )
+        battle_items.lock_item = data.get("lock_item", False)
+        return battle_items
+
+    def __repr__(self):
+        return f"BattleItems({self.items})"
+
+    def __str__(self):
+        return f"BattleItems({self.items})"
+
+    def get_names(self, save_file: core.SaveFile) -> list[str] | None:
+        names = core.core_data.get_gatya_item_names(save_file).names
+        if names is None:
+            return None
+        items = core.core_data.get_gatya_item_buy(save_file).get_by_category(3)
+        if items is None:
+            return None
+
+        names = [names[item.id] for item in items]
+        return names
+
+    def edit(self, save_file: core.SaveFile):
+        group_name = save_file.get_localizable().get("shop_category1")
+        if group_name is None:
+            group_name = core.core_data.local_manager.get_key("battle_items")
+        item_names = self.get_names(save_file)
+        if item_names is None:
+            return
+        current_values = [item.amount for item in self.items]
+        values = dialog_creator.MultiEditor.from_reduced(
+            group_name,
+            item_names,
+            current_values,
+            core.core_data.max_value_manager.get("battle_items"),
+        ).edit()
+        for i, value in enumerate(values):
+            self.items[i].amount = value
+
+    def edit_endless_items(self, save_file: core.SaveFile):
+        item_names = self.get_names(save_file)
+        if item_names is None:
+            return
+
+        current_values = [
+            item.endless_item.get_endless_duration_formatted() for item in self.items
+        ]
+
+        (options, all_at_once) = dialog_creator.ChoiceInput.from_reduced(
+            [core.localize("endless_item_item", item=item) for item in item_names],
+            current_values,
+            localize_options=False,
+            dialog="select_option",
+        ).multiple_choice(False)
+
+        if options is None:
+            return
+
+        infinity_str = core.localize("infinity")
+
+        if all_at_once:
+            val = dialog_creator.StringInput().get_input_locale_while(
+                "enter_duration_minutes", {}
+            )
+            if val is None:
+                return
+
+            if val.lower() == infinity_str.lower():
+                val = inf
+            else:
+                try:
+                    val = float(val)
+                except ValueError:
+                    return
+
+            for item in self.items:
+                item.endless_item.set_duration_mins(val, 0)
+        else:
+            for opt in options:
+                val = dialog_creator.StringInput().get_input_locale_while(
+                    "enter_duration_minutes_item", {"item": item_names[opt]}
+                )
+                if val is None:
+                    return
+
+                if val.lower() == infinity_str.lower():
+                    val = inf
+                else:
+                    try:
+                        val = float(val)
+                    except ValueError:
+                        color.ColoredText.localize("invalid_minute_count")
+                        continue
+
+                self.items[opt].endless_item.set_duration_mins(val, 0)
+
+        color.ColoredText.localize("endless_items_success")

{bcsfe-3.2.0b3 → bcsfe-3.2.1}/src/bcsfe/core/io/path.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 import glob
 import os
 import shutil
-import typing
 
 from bcsfe import core
 import re
@@ -88,12 +87,17 @@ class Path:
         path.generate_dirs()
         return path
 
+    def is_empty(self) -> bool:
+        return self.path == ""
+
     def generate_dirs(self: Path) -> Path:
+        if self.is_empty():
+            return self
         if not self.exists():
             try:
                 self.__make_dirs()
-            except OSError:
-                pass
+            except OSError as e:
+                print(e, self)
         return self
 
     def create(self) -> Path:

{bcsfe-3.2.0b3 → bcsfe-3.2.1}/src/bcsfe/core/io/save.py

@@ -794,15 +794,7 @@ class SaveFile:
             assert self.data.read_int() == 100100
 
         if self.game_version >= 100300:
-            self.utl2: list[tuple[bool, bool, int, float, float]] = []
-            length = 6
-            for _ in range(length):
-                b1 = self.data.read_bool()
-                b2 = self.data.read_bool()
-                i1 = self.data.read_byte()
-                f1 = self.data.read_double()
-                f2 = self.data.read_double()
-                self.utl2.append((b1, b2, i1, f1, f2))
+            self.battle_items.read_endless_items(self.data)
 
             assert self.data.read_int() == 100300
 
@@ -1881,30 +1873,7 @@ class SaveFile:
             self.data.write_int(100100)
 
         if self.game_version >= 100300:
-            for i in range(6):
-                try:
-                    item = self.utl2[i]
-                except IndexError:
-                    item = (False, False, 0, 0.0, 0.0)
-
-                tuple_len = len(item)
-                b1, b2, i1, f1, f2 = False, False, 0, 0.0, 0.0
-                if tuple_len >= 1:
-                    b1 = item[0]
-                if tuple_len >= 2:
-                    b2 = item[1]
-                if tuple_len >= 3:
-                    i1 = item[2]
-                if tuple_len >= 4:
-                    f1 = item[3]
-                if tuple_len >= 5:
-                    f2 = item[4]
-
-                self.data.write_bool(b1)
-                self.data.write_bool(b2)
-                self.data.write_byte(i1)
-                self.data.write_double(f1)
-                self.data.write_double(f2)
+            self.battle_items.write_endless_items(self.data)
 
             self.data.write_int(100300)
 
@@ -2504,7 +2473,6 @@ class SaveFile:
             "ud8": self.ud8,
             "ud9": self.ud9,
             "date_int": self.date_int,
-            "utl2": self.utl2,
             "event_capsules_2": self.event_capsules_2,
             "two_battle_lines": self.two_battle_lines,
             "ud10": self.ud10,
@@ -2884,7 +2852,6 @@ class SaveFile:
         save_file.ud8 = data.get("ud8", 0.0)
         save_file.ud9 = data.get("ud9", 0.0)
         save_file.date_int = data.get("date_int", 0)
-        save_file.utl2 = data.get("utl2", [(False, False, 0, 0.0, 0.0)] * 6)
         save_file.event_capsules_2 = data.get("event_capsules_2", [])
         save_file.two_battle_lines = data.get("two_battle_lines", False)
         save_file.ud10 = data.get("ud10", 0.0)
@@ -3205,7 +3172,6 @@ class SaveFile:
         self.ushl6 = []
 
         self.utl1 = []
-        self.utl2 = [(False, False, 0, 0.0, 0.0)] * 6
         self.utl3 = []
         self.utl4 = []
 

{bcsfe-3.2.0b3 → bcsfe-3.2.1}/src/bcsfe/core/server/game_data_getter.py

@@ -141,6 +141,8 @@ class GameDataGetter:
 
         archive.extractall(outdir.path)
 
+        outdir.add("downloaded").write(core.Data())
+
         return True
 
     def get_version_path(self) -> core.Path | None:
@@ -150,11 +152,11 @@ class GameDataGetter:
             GameDataGetter.get_game_data_dir().add(self.cc.get_code()).add(self.version)
         ).generate_dirs()
 
-    def is_missing(self) -> bool:
+    def has_downloaded(self) -> bool:
         path = self.get_version_path()
         if path is None:
             return False
-        return len(path.add("DataLocal").get_files()) != 0
+        return path.add("downloaded").exists()
 
     def get_file(self, pack_name: str, file_name: str) -> core.Data | bool:
         path = self.get_file_path(pack_name, file_name)
@@ -164,7 +166,7 @@ class GameDataGetter:
         if path.exists():
             return path.read()
         else:
-            if self.is_missing():
+            if self.has_downloaded():
                 return True
             if self.download_version_data() is None:
                 return False
@@ -175,7 +177,7 @@ class GameDataGetter:
 
             if path.exists():
                 return path.read()
-            return self.is_missing()
+            return self.has_downloaded()
 
     def save_file(self, pack_name: str, file_name: str) -> core.Data | bool:
         pack_name = self.get_packname(pack_name)
@@ -243,7 +245,7 @@ class GameDataGetter:
                 self.print_no_file(pack_name, file_name)
             return None
 
-        if display_text and not self.is_missing():
+        if display_text and not self.has_downloaded():
             color.ColoredText.localize(
                 "downloading",
                 file_name=file_name,

{bcsfe-3.2.0b3 → bcsfe-3.2.1}/src/bcsfe/files/locales/en/edits/items.properties

@@ -27,6 +27,15 @@ np=NP
 leadership=Leadership
 catseyes=Catseyes
 battle_items=Battle Items
+duration=<@t>{days}</t> days, <@t>{hours}</t> hours, <@t>{minutes}</> minutes, <@t>{seconds}</> seconds
+endless_item_item=<@s>{item}</> : <@s>{int}</>
+endless_items_success=<@su>Successfully edited endless items</>
+invalid_minute_count=<@e>Invalid minute amount</>
+enter_duration_minutes=Enter the duration in minutes for the endless items to last for (if you enter <@t>infinity</> the items last forever):
+infinity_duration=<@t>infinity</>
+infinity=Infinity
+enter_duration_minutes_item=Enter the duration in minutes for the endless <@t>{item}</> to last for (if you enter <@t>infinity</> the items last forever):
+battle_items_endless=Endless Battle Items
 talent_orbs=Talent Orbs
 scheme_items=Scheme Items
 labyrinth_medals=Labyrinth Medals

{bcsfe-3.2.0b3 → bcsfe-3.2.1}/src/bcsfe/files/locales/vi/core/input.properties

@@ -27,4 +27,6 @@ select_features=
 >Đầu vào:
 
 individual=Cá nhân
-edit_all_at_once=Tất cả cùng lúc
+edit_all_at_once=Tất cả cùng lúc
+finish=Hoàn thành
+select_option=Chọn tùy chọn: