From 5598f4acfcfe36552cb6f140d258295ad949c184 Mon Sep 17 00:00:00 2001 From: Deadbot0 Date: Thu, 21 May 2026 15:18:52 +0000 Subject: [PATCH 01/12] chore: incremented version --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index cf3a36f4..2a87cdbe 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "Deadbot" -version = "1.11.1" +version = "1.11.1-beta.1" description = "Bot that lives to serve deadlock.wiki" readme = "README.md" authors=[] From 0e690fded9add0df33196b64ca6d73685b20bc9f Mon Sep 17 00:00:00 2001 From: Deadbot0 Date: Sat, 23 May 2026 21:56:56 +0000 Subject: [PATCH 02/12] chore: incremented version --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 1af68a13..ad9cf36c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "Deadbot" -version = "1.11.2" +version = "1.11.2-beta.1" description = "Bot that lives to serve deadlock.wiki" readme = "README.md" authors=[] From 816ec0cf33c4edd64f11cbd0d9f28348f0ca286e Mon Sep 17 00:00:00 2001 From: Daniil Popov Date: Mon, 25 May 2026 23:04:29 +0200 Subject: [PATCH 03/12] feat: extract modifier hierarchy from abilities (#367) Co-authored-by: hassayag <56391012+hassayag@users.noreply.github.com> --- src/parser/parsers/abilities/__main__.py | 7 +- src/parser/parsers/abilities/modifiers.py | 91 +++++++++++++++++++++++ src/parser/parsers/abilities/upgrades.py | 6 +- 3 files changed, 98 insertions(+), 6 deletions(-) create mode 100644 src/parser/parsers/abilities/modifiers.py diff --git a/src/parser/parsers/abilities/__main__.py b/src/parser/parsers/abilities/__main__.py index 20b2ec70..5e21f7a3 100644 --- a/src/parser/parsers/abilities/__main__.py +++ b/src/parser/parsers/abilities/__main__.py @@ -3,6 +3,7 @@ import utils.json_utils as json_utils import utils.num_utils as num_utils from .upgrades import parse_upgrades +from .modifiers import parse_modifiers from loguru import logger @@ -54,10 +55,8 @@ def _parse_ability(self, ability_key): else: ability_data[key] = value - if 'm_vecAbilityUpgrades' in ability: - ability_data['Upgrades'] = parse_upgrades(ability) - else: - ability_data['Upgrades'] = [] + ability_data.update(parse_upgrades(ability)) + ability_data.update(parse_modifiers(ability)) formatted_ability_data = {} for attr_key, attr_value in ability_data.items(): diff --git a/src/parser/parsers/abilities/modifiers.py b/src/parser/parsers/abilities/modifiers.py new file mode 100644 index 00000000..3889d982 --- /dev/null +++ b/src/parser/parsers/abilities/modifiers.py @@ -0,0 +1,91 @@ +import re + + +_PREFIX_RE = re.compile(r'[A-Z]') +_MODIFIER_VALUES_KEY = 'm_vecAutoRegisterModifierValueFromAbilityPropertyName' + + +def parse_modifiers(ability: dict) -> dict: + """Walk an ability and extract a nested modifier hierarchy. + + Any key whose name contains 'modifier' (case-insensitive). + The output uses the same keys as source but strips the prefixes + (e.g. m_DebuffModifier -> DebuffModifier, + m_AutoIntrinsicModifiers -> AutoIntrinsicModifiers). + + From each modifier node, copy: + - _class -> Class (verbatim, only if a non-empty string) + - _my_subclass_name -> Subclass (verbatim, only if a non-empty string) + - m_vecAutoRegisterModifierValueFromAbilityPropertyName -> + AutoRegisterModifierValueFromAbilityPropertyName (verbatim list of + property names, only if non-empty). + - direct int/float children -> key stripped of its lowercase prefix + (e.g. m_flDuration -> Duration), value verbatim. + - nested modifier-named children, recursively (same recursion gate). + + Nodes that end up with no fields at all (only empty class etc.) are omitted. + """ + return _parse_dict_modifiers(ability) + + +def _strip_prefix(key: str) -> str: + match = _PREFIX_RE.search(key) + if match: + return key[match.start() :] + return key + + +def _parse_dict_modifiers(node: dict) -> dict: + out = {} + for k, v in node.items(): + if 'modifier' not in k.lower(): + continue + parsed = _parse_modifier_value(v) + if parsed is not None: + out[_strip_prefix(k)] = parsed + return out + + +def _parse_modifier_value(value): + if isinstance(value, dict): + return _parse_modifier_node(value) + if isinstance(value, list): + items = [] + for item in value: + if not isinstance(item, dict): + continue + parsed = _parse_modifier_node(item) + if parsed is not None: + items.append(parsed) + return items if items else None + return None + + +def _parse_modifier_node(node: dict) -> dict | None: + out = {} + + cls = node.get('_class') + if isinstance(cls, str) and cls: + out['Class'] = cls + subclass = node.get('_my_subclass_name') + if isinstance(subclass, str) and subclass: + out['Subclass'] = subclass + + auto_register = node.get(_MODIFIER_VALUES_KEY) + if isinstance(auto_register, list) and auto_register: + out[_strip_prefix(_MODIFIER_VALUES_KEY)] = auto_register + + for k, v in node.items(): + if k in ('_class', '_my_subclass_name', _MODIFIER_VALUES_KEY): + continue + if isinstance(v, bool): + continue + if isinstance(v, (int, float)): + out[_strip_prefix(k)] = v + continue + if 'modifier' in k.lower(): + parsed = _parse_modifier_value(v) + if parsed is not None: + out[_strip_prefix(k)] = parsed + + return out or None diff --git a/src/parser/parsers/abilities/upgrades.py b/src/parser/parsers/abilities/upgrades.py index bbe77eff..55fa45c0 100644 --- a/src/parser/parsers/abilities/upgrades.py +++ b/src/parser/parsers/abilities/upgrades.py @@ -31,7 +31,9 @@ class RawUpgrade(TypedDict): SCALE_UPGRADE_TYPES = ['EAddToScale', 'EMultiplyScale'] -def parse_upgrades(ability): +def parse_upgrades(ability: dict) -> dict: + if 'm_vecAbilityUpgrades' not in ability: + return {'Upgrades': []} upgrade_sets = ability['m_vecAbilityUpgrades'] parsed_upgrade_sets = [] @@ -115,4 +117,4 @@ def parse_upgrades(ability): parsed_upgrade_sets.append(parsed_upgrade_set) - return parsed_upgrade_sets + return {'Upgrades': parsed_upgrade_sets} From 98ea5540a2b67343afc7ba9e2eea39e767e56dd6 Mon Sep 17 00:00:00 2001 From: Deadbot0 Date: Mon, 25 May 2026 21:04:38 +0000 Subject: [PATCH 04/12] chore: incremented version --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index ad9cf36c..c2ffdb29 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "Deadbot" -version = "1.11.2-beta.1" +version = "1.11.2-beta.2" description = "Bot that lives to serve deadlock.wiki" readme = "README.md" authors=[] From c3de6a2b7a7da41a2e8bb6bd80546b66b656d877 Mon Sep 17 00:00:00 2001 From: LVL1024 <70866179+LVL1024@users.noreply.github.com> Date: Mon, 25 May 2026 18:28:07 -0400 Subject: [PATCH 05/12] feat: parse misc.vdata and export as misc-data.json (#375) --- src/parser/parser.py | 8 +++ src/parser/parsers/misc.py | 101 +++++++++++++++++++++++++++++++++++++ src/wiki/pages.py | 1 + 3 files changed, 110 insertions(+) create mode 100644 src/parser/parsers/misc.py diff --git a/src/parser/parser.py b/src/parser/parser.py index c95ca888..179b0d69 100644 --- a/src/parser/parser.py +++ b/src/parser/parser.py @@ -14,6 +14,7 @@ generics, npc_units, game_map, + misc, ) from utils import json_utils from loguru import logger @@ -148,6 +149,7 @@ def run(self): self._parse_localizations() self._parse_soul_unlocks() self._parse_generics() + self._parse_misc() self._parse_map() logger.trace('Done parsing') @@ -309,3 +311,9 @@ def _generate_resource_lookup(self, parsed_heroes, parsed_abilities, parsed_item ).run() json_utils.write(self.OUTPUT_DIR + '/json/resource-lookup.json', lookup) + + def _parse_misc(self): + logger.trace('Parsing Misc...') + parsed_misc = misc.MiscParser(self.data['scripts']['misc']).run() + + json_utils.write(self.OUTPUT_DIR + '/json/misc-data.json', json_utils.sort_dict(parsed_misc)) diff --git a/src/parser/parsers/misc.py b/src/parser/parsers/misc.py new file mode 100644 index 00000000..6a7d049a --- /dev/null +++ b/src/parser/parsers/misc.py @@ -0,0 +1,101 @@ +import utils.string_utils as string_utils + + +class MiscParser: + """ + Parses misc.vdata by stripping prefixes and filtering out internal data, + then uploads the whole thing. + Same approach as GenericParser. + """ + + # Prefixes to strip from keys, sorted longest-first to prevent + # partial matches (e.g. "m_nav" before "m_n") + PREFIXES = sorted( + [ + 'm_fl', + 'm_b', + 'm_n', + 'm_i', + 'm_str', + 'm_vec', + 'm_map', + 'm_e', + 'm_subclass', + 'm_s', + 'm_', + ], + key=len, + reverse=True, + ) + + # Internal metadata keys to remove + METADATA_KEYS = { + '_class', + '_my_subclass_name', + '_base', + '_not_pickable', + 'generic_data_type', + } + + def __init__(self, misc_data): + self.misc_data = misc_data + + def run(self): + parsed = self._remove_prefixes(self.misc_data, self.PREFIXES) + return parsed + + def _remove_prefixes(self, data, prefixes): + """Recursively strip prefixes from keys and filter out internal data.""" + if isinstance(data, dict): + result = {} + + for key, value in data.items(): + # Skip internal metadata keys + if key in self.METADATA_KEYS: + continue + + # Skip base class definitions + if key.endswith('_base'): + continue + + # Strip prefix from key + clean_key = key + for prefix in prefixes: + clean_key = string_utils.remove_prefix(key, prefix) + if clean_key != key: + break + + # Force-strip m_ prefix when followed by lowercase + # e.g. m_modifierProvidedByAura -> modifierProvidedByAura + if clean_key.startswith('m_') and len(clean_key) > 2: + clean_key = clean_key[2:] + + # Recurse into nested structures + if isinstance(value, dict): + value = self._remove_prefixes(value, prefixes) + elif isinstance(value, list): + value = self._remove_prefixes_from_list(value, prefixes) + + # Skip empty containers after filtering + if isinstance(value, (dict, list)) and len(value) == 0: + continue + + result[clean_key] = value + + return result if result else {} + + elif isinstance(data, list): + return self._remove_prefixes_from_list(data, prefixes) + + return data + + def _remove_prefixes_from_list(self, data, prefixes): + result = [] + for item in data: + if isinstance(item, dict): + parsed = self._remove_prefixes(item, prefixes) + if parsed: + result.append(parsed) + else: + result.append(item) + return result if result else [] diff --git a/src/wiki/pages.py b/src/wiki/pages.py index 39aa3ac3..867477e7 100644 --- a/src/wiki/pages.py +++ b/src/wiki/pages.py @@ -43,6 +43,7 @@ 'StatInfoboxOrder.json': 'json/stat-infobox-order.json', 'ResourceLookup.json': 'json/resource-lookup.json', 'MidtownMetadata.json': 'json/midtown-metadata.json', + 'MiscData.json': 'json/misc-data.json', } # Ignore these pages as they are not automated From 65374c66c7de4bd0f0f0bdb0e0cfb1c12630e0ac Mon Sep 17 00:00:00 2001 From: Deadbot0 Date: Mon, 25 May 2026 22:28:14 +0000 Subject: [PATCH 06/12] chore: incremented version --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index c2ffdb29..0886f75b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "Deadbot" -version = "1.11.2-beta.2" +version = "1.11.2-beta.3" description = "Bot that lives to serve deadlock.wiki" readme = "README.md" authors=[] From 881e509601609962e07489528efe1147668c3fef Mon Sep 17 00:00:00 2001 From: Deadbot0 Date: Tue, 26 May 2026 03:33:24 +0000 Subject: [PATCH 07/12] [skip ci] chore: updated input data --- input-data/changelogs/changelog_configs.json | 6 ++++++ input-data/changelogs/raw/2026-05-25.txt | 13 +++++++++++++ 2 files changed, 19 insertions(+) create mode 100644 input-data/changelogs/raw/2026-05-25.txt diff --git a/input-data/changelogs/changelog_configs.json b/input-data/changelogs/changelog_configs.json index c4cc9c65..428316d9 100644 --- a/input-data/changelogs/changelog_configs.json +++ b/input-data/changelogs/changelog_configs.json @@ -742,5 +742,11 @@ "date": "2026-05-22", "link": "https://forums.playdeadlock.com/threads/05-22-2026-update.135477/", "is_hero_lab": false + }, + "2026-05-25": { + "forum_id": "135477", + "date": "2026-05-25", + "link": "https://forums.playdeadlock.com/threads/05-22-2026-update.135477/post-259788", + "is_hero_lab": false } } \ No newline at end of file diff --git a/input-data/changelogs/raw/2026-05-25.txt b/input-data/changelogs/raw/2026-05-25.txt new file mode 100644 index 00000000..a417d7e6 --- /dev/null +++ b/input-data/changelogs/raw/2026-05-25.txt @@ -0,0 +1,13 @@ +* Urn drop off point is moved from the above bridge in the mid lane to under the bridge in the side lane +* Urn timer extension when contested increased from 1.25s to 3s +* Urn deposit timers for favored/neutral/unfavored increased from 3/5/10s to 5/10/15s +* Urn comeback bullet and spirit resist auras reduced from 50% to 35% +* Urn pickup spot is now where the old comeback drop off spots were for when your team is behind +* Urn runner no longer has sprint disabled +* Urn runner now has max sprint acceleration +* Urn runner now gains +2m Sprint, +1 Stamina, +10% Dash Distance and +15% Stamina Regen +* Urn runner for the team that is behind now gains an extra +4m Sprint +* Urn collision radius increased by 20% +* Various smaller urn holding timers and variables adjusted to account for the new location + +Please continue to give feedback on the Urn as we work through iterations on it. \ No newline at end of file From 29e8272d49324d7c0c5a15fda09e3f9a71388835 Mon Sep 17 00:00:00 2001 From: LVL1024 <70866179+LVL1024@users.noreply.github.com> Date: Tue, 26 May 2026 20:33:25 -0400 Subject: [PATCH 08/12] fix: defaulting to spirit scaling when scale type is missing (#374) --- src/parser/maps.py | 46 ++++++++++++++++++++++++ src/parser/parsers/abilities/__main__.py | 34 ++++++++++++------ src/parser/parsers/abilities/upgrades.py | 6 ++-- src/parser/parsers/items.py | 12 +++++-- 4 files changed, 82 insertions(+), 16 deletions(-) diff --git a/src/parser/maps.py b/src/parser/maps.py index 74f814db..b8e75d58 100644 --- a/src/parser/maps.py +++ b/src/parser/maps.py @@ -201,6 +201,52 @@ def override_localization(attr): } +def class_to_scale_type(class_str: str) -> str | None: + """ + Infer the human-readable scale type from a _class string. + Returns a value like 'spirit', 'range', 'duration', 'cooldown', etc. + """ + if not class_str: + return None + + # Pattern 1: scale_function_ + if class_str.startswith('scale_function_'): + suffix = class_str[len('scale_function_') :] + # Map suffix to SCALE_TYPE_MAP key, then to human type + suffix_to_enum = { + 'tech_damage': 'ETechPower', + 'tech_range': 'ETechRange', + 'tech_duration': 'ETechDuration', + 'tech_cooldown': 'ETechCooldown', + 'weapon_damage': 'EWeaponDamageScale', + 'ability_charges': 'EMaxChargesIncrease', + 'ability_recharge_time': 'ETechCooldown', # cooldown between charges + } + enum_key = suffix_to_enum.get(suffix) + if enum_key: + return SCALE_TYPE_MAP.get(enum_key) + + # Pattern 2: CScaleFunction (e.g., CTechPowerScaleFunction) + elif class_str.startswith('C') and class_str.endswith('ScaleFunction'): + middle = class_str[1 : -len('ScaleFunction')] # e.g., 'TechPower' + enum_key = 'E' + middle + return SCALE_TYPE_MAP.get(enum_key) + + return None + + +def class_to_scale_enum(class_str: str) -> str | None: + """Return the enum key (e.g., 'ETechRange') from a _class string.""" + human_type = class_to_scale_type(class_str) + if not human_type: + return None + # Reverse lookup in SCALE_TYPE_MAP + for enum_key, human in SCALE_TYPE_MAP.items(): + if human == human_type: + return enum_key + return None + + def get_scale_type(scale): if scale is None: return scale diff --git a/src/parser/parsers/abilities/__main__.py b/src/parser/parsers/abilities/__main__.py index 5e21f7a3..55964083 100644 --- a/src/parser/parsers/abilities/__main__.py +++ b/src/parser/parsers/abilities/__main__.py @@ -81,14 +81,26 @@ def _get_scale(self, stat): Get scale data for the ability attribute, which will refer to how the value of the attribute scales with another stat, usually Spirit """ - if 'm_subclassScaleFunction' in stat: - scale = stat['m_subclassScaleFunction'] - # Only include scale with a value, as not sure what - # any others mean so far. - if 'm_flStatScale' in scale: - return { - 'Value': scale['m_flStatScale'], - 'Type': maps.get_scale_type(scale.get('m_eSpecificStatScaleType', 'ETechPower')), - } - - return + if 'm_subclassScaleFunction' not in stat: + return + scale = stat['m_subclassScaleFunction'] + if 'm_flStatScale' not in scale: + return + + scale_type = scale.get('m_eSpecificStatScaleType') + human_type = None + if scale_type: + human_type = maps.get_scale_type(scale_type) + else: + # Fallback: infer from _class + class_str = scale.get('_class', '') + if class_str: + human_type = maps.class_to_scale_type(class_str) + if not human_type: + # Last resort: default to spirit + human_type = maps.get_scale_type('ETechPower') + + return { + 'Value': scale['m_flStatScale'], + 'Type': human_type, + } diff --git a/src/parser/parsers/abilities/upgrades.py b/src/parser/parsers/abilities/upgrades.py index 55fa45c0..7051fae1 100644 --- a/src/parser/parsers/abilities/upgrades.py +++ b/src/parser/parsers/abilities/upgrades.py @@ -91,8 +91,10 @@ def parse_upgrades(ability: dict) -> dict: if base_stat and 'm_subclassScaleFunction' in base_stat: scale_func = base_stat['m_subclassScaleFunction'] scale_type = scale_func.get('m_eSpecificStatScaleType') - if scale_type is None and 'tech' in scale_func.get('_class', ''): - scale_type = 'ETechPower' + if scale_type is None: + class_str = scale_func.get('_class', '') + if class_str: + scale_type = maps.class_to_scale_enum(class_str) scale = { 'Value': entry['value'], 'Type': maps.get_scale_type(scale_type), diff --git a/src/parser/parsers/items.py b/src/parser/parsers/items.py index 435ac25e..66a01e8b 100644 --- a/src/parser/parsers/items.py +++ b/src/parser/parsers/items.py @@ -172,14 +172,20 @@ def _extract_scaling(self, attr: Dict[str, Any], item_key: str, attr_key: str) - return None scale_type = scale_func.get('m_eSpecificStatScaleType') - human_type = get_scale_type(scale_type) + human_type = get_scale_type(scale_type) if scale_type else None + + # Fallback to inferring from _class if not human_type: - return None + class_str = scale_func.get('_class', '') + if class_str: + human_type = maps.class_to_scale_type(class_str) + if not human_type: + return None try: base_value = num_utils.assert_number(base_value_str) scale_value = num_utils.assert_number(raw_scale_value) - if math.isnan(scale_value) or math.isinf(scale_value): + if math.isnan(scale_value) or math.isinf(scale_value) or scale_value == 0: return None except (ValueError, TypeError): return None From 36f3df313bf2301469adde8df44905c372733a87 Mon Sep 17 00:00:00 2001 From: Deadbot0 Date: Wed, 27 May 2026 00:33:34 +0000 Subject: [PATCH 09/12] chore: incremented version --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 0886f75b..c2be1370 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "Deadbot" -version = "1.11.2-beta.3" +version = "1.11.2-beta.4" description = "Bot that lives to serve deadlock.wiki" readme = "README.md" authors=[] From 21514d1f0422309f6d17e03a30321d04346bfdc6 Mon Sep 17 00:00:00 2001 From: hassayag <56391012+hassayag@users.noreply.github.com> Date: Wed, 27 May 2026 11:51:03 +0100 Subject: [PATCH 10/12] fix: convert base value perc increase to a simple multiplier (#379) --- src/parser/parsers/abilities/upgrades.py | 22 ++++++++++++++++------ 1 file changed, 16 insertions(+), 6 deletions(-) diff --git a/src/parser/parsers/abilities/upgrades.py b/src/parser/parsers/abilities/upgrades.py index 7051fae1..f18a5644 100644 --- a/src/parser/parsers/abilities/upgrades.py +++ b/src/parser/parsers/abilities/upgrades.py @@ -1,17 +1,19 @@ from parser import maps from . import utils from utils import json_utils, num_utils -from typing import TypedDict +from typing import NotRequired, TypedDict class ScaleEntry(TypedDict): Value: int | float Type: str | None + Multiply: NotRequired[bool] class UpgradeWithScale(TypedDict): Value: int | float Scale: ScaleEntry | list[ScaleEntry] + Multiply: NotRequired[bool] ParsedUpgradeValue = int | float | UpgradeWithScale @@ -95,7 +97,7 @@ def parse_upgrades(ability: dict) -> dict: class_str = scale_func.get('_class', '') if class_str: scale_type = maps.class_to_scale_enum(class_str) - scale = { + scale: ScaleEntry = { 'Value': entry['value'], 'Type': maps.get_scale_type(scale_type), } @@ -107,15 +109,23 @@ def parse_upgrades(ability: dict) -> dict: raise Exception(f'Unhandled upgrade type {entry["upgrade_type"]}') if scales: + parsed_upgrade: ParsedUpgradeValue = {} # if there are multiple scales for a prop, output as an array if len(scales) > 1: - parsed_upgrade_set[prop] = {'Value': base_value, 'Scale': scales} + parsed_upgrade = {'Value': base_value, 'Scale': scales} else: - parsed_upgrade_set[prop] = {'Value': base_value, 'Scale': scales[0]} + parsed_upgrade = {'Value': base_value, 'Scale': scales[0]} + if multiply_base: - parsed_upgrade_set[prop]['Multiply'] = True + parsed_upgrade['Multiply'] = True + # convert the game's percentage increase to a simple multiplication + # as this convention is used by multiply of scale upgrade + # eg. 113 -> 1.13 + 1 = 2.13 + parsed_upgrade['Value'] = base_value / 100 + 1 else: - parsed_upgrade_set[prop] = base_value + parsed_upgrade = base_value + + parsed_upgrade_set[prop] = parsed_upgrade parsed_upgrade_sets.append(parsed_upgrade_set) From 3f168f991d5a9db606886f13550642161cac6281 Mon Sep 17 00:00:00 2001 From: Deadbot0 Date: Wed, 27 May 2026 10:51:11 +0000 Subject: [PATCH 11/12] chore: incremented version --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index c2be1370..2dc8d2a2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "Deadbot" -version = "1.11.2-beta.4" +version = "1.11.2-beta.5" description = "Bot that lives to serve deadlock.wiki" readme = "README.md" authors=[] From 2432ed23d9bcb0b70599b6f40753cb7ab0c560f5 Mon Sep 17 00:00:00 2001 From: Deadbot0 Date: Wed, 27 May 2026 10:52:43 +0000 Subject: [PATCH 12/12] [skip ci] chore: bumped version to 1.12.0 --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 2dc8d2a2..4e8302e5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "Deadbot" -version = "1.11.2-beta.5" +version = "1.12.0" description = "Bot that lives to serve deadlock.wiki" readme = "README.md" authors=[]