albibong 1.0.4__tar.gz → 1.0.6__tar.gz

{albibong-1.0.4 → albibong-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: albibong
-Version: 1.0.4
+Version: 1.0.6
 Summary: A cross-platform Albion Online damage, fame, and dungeon tracker
 Project-URL: Homepage, https://github.com/imjangkar/albibong
 Project-URL: Issues, https://github.com/imjangkar/albibong/issues
@@ -9,8 +9,7 @@ License-File: LICENSE
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.8
-Requires-Dist: playsound==1.3.0
+Requires-Python: >=3.10
 Requires-Dist: pywebview==5.1
 Requires-Dist: scapy==2.5.0
 Requires-Dist: websockets==12.0

{albibong-1.0.4 → albibong-1.0.6}/pyproject.toml

@@ -19,12 +19,12 @@ albibong = "albibong:main"
 
 [project]
 name = "albibong"
-version = "1.0.4"
+version = "1.0.6"
 authors = [
   { name="imjangkar", email="imjangkar@gmail.com" },
 ]
 description = "A cross-platform Albion Online damage, fame, and dungeon tracker"
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: MIT License",
@@ -34,7 +34,6 @@ dependencies = [
   "scapy==2.5.0",
   "websockets==12.0",
   "pywebview==5.1",
-  "playsound==1.3.0"
 ]
 
 [project.urls]

{albibong-1.0.4 → albibong-1.0.6}/src/albibong/classes/character.py

@@ -1,3 +1,4 @@
+from datetime import datetime, timedelta
 import json
 from uuid import UUID
 
@@ -20,25 +21,46 @@ class Character:
         coords: Coords,
         equipment: list[Item] = [Item.get_item_from_code("0")] * 10,
     ):
+        # Profile
         self.id = id
         self.uuid = uuid
         self.username = username
         self.guild = guild
         self.alliance = alliance
         self.coords = coords
+        self.equipment = equipment
+
+        # Stats
         self.fame_gained: int = 0
         self.re_spec_gained: int = 0
         self.silver_gained: int = 0
+        self.loot: list[str] = []
+
+        # Combat
         self.damage_dealt: int = 0
         self.healing_dealt: int = 0
-        self.loot: list[str] = []
-        self.equipment = equipment
+        self.is_already_in_combat: bool = False
+        self.start_combat_time: timedelta = timedelta(0, 0)
+        self.total_combat_duration: timedelta = timedelta(0, 0)
+
+    def update_combat_duration(self, is_starting_combat):
+        if self.is_already_in_combat == False:
+            if is_starting_combat == True:
+                self.is_already_in_combat = True
+                self.start_combat_time = datetime.now()
+        else:
+            if is_starting_combat == False:
+                self.is_already_in_combat = False
+                current_combat_duration = datetime.now() - self.start_combat_time
+                self.total_combat_duration += current_combat_duration
 
     def update_damage_dealt(self, nominal):
-        self.damage_dealt += nominal
+        if self.is_already_in_combat:
+            self.damage_dealt += nominal
 
     def update_heal_dealt(self, nominal):
-        self.healing_dealt += nominal
+        if self.is_already_in_combat:
+            self.healing_dealt += nominal
 
     def update_coords(self, parameters):
         if 3 in parameters:
@@ -49,7 +71,7 @@ class Character:
         self.fame_gained += fame
         event = {
             "type": "update_fame",
-            "payload": {"username": self.username, "fame_gained": fame},
+            "payload": {"username": self.username, "fame_gained": self.fame_gained},
         }
         send_event(event)
 
@@ -58,7 +80,10 @@ class Character:
         self.re_spec_gained += re_spec
         event = {
             "type": "update_re_spec",
-            "payload": {"username": self.username, "re_spec_gained": re_spec},
+            "payload": {
+                "username": self.username,
+                "re_spec_gained": self.re_spec_gained,
+            },
         }
         send_event(event)
 
@@ -69,7 +94,10 @@ class Character:
                 self.silver_gained += silver
                 event = {
                     "type": "update_silver",
-                    "payload": {"username": self.username, "silver_gained": silver},
+                    "payload": {
+                        "username": self.username,
+                        "silver_gained": self.silver_gained,
+                    },
                 }
                 send_event(event)
         else:

albibong-1.0.6/src/albibong/classes/event_handler/__init__.py

@@ -0,0 +1,116 @@
+from albibong.classes.event_handler.handle_event_character_equipment_changed import (
+    handle_event_character_equipment_changed,
+)
+from albibong.classes.event_handler.handle_event_health import (
+    handle_event_health_update,
+    handle_event_health_updates,
+)
+from albibong.classes.event_handler.handle_event_in_combat_state_update import (
+    handle_event_in_combat_state_update,
+)
+from albibong.classes.event_handler.handle_event_new_character import (
+    handle_event_new_character,
+)
+from albibong.classes.event_handler.handle_event_other_grabbed_loot import (
+    handle_event_other_grabbed_loot,
+)
+from albibong.classes.event_handler.handle_event_party import (
+    handle_event_party_disbanded,
+    handle_event_party_joined,
+    handle_event_party_player_joined,
+    handle_event_party_player_left,
+)
+from albibong.classes.event_handler.handle_event_update_fame import (
+    handle_event_update_fame,
+)
+from albibong.classes.event_handler.handle_event_update_re_spec_points import (
+    handle_event_update_re_spec_points,
+)
+from albibong.classes.event_handler.handle_operation_change_cluster import (
+    handle_operation_change_cluster,
+)
+from albibong.classes.event_handler.handle_operation_join import handle_operation_join
+from albibong.classes.event_handler.handle_operation_move import handle_operation_move
+from albibong.classes.world_data import WorldData
+from albibong.resources.EventCode import EventCode
+from albibong.resources.OperationCode import OperationCode
+
+
+EVENT_TYPE_PARAMETER = 252
+REQUEST_TYPE_PARAMETER = 253
+RESPONSE_TYPE_PARAMETER = 253
+
+
+class EventHandler:
+    def __init__(self):
+        self.request_handler = {}
+        self.response_handler = {}
+        self.event_handler = {}
+
+        # Event Handler
+        self.event_handler[EventCode.NEW_CHARACTER.value] = handle_event_new_character
+        self.event_handler[EventCode.HEALTH_UPDATE.value] = handle_event_health_update
+        self.event_handler[EventCode.HEALTH_UPDATES.value] = handle_event_health_updates
+        self.event_handler[EventCode.IN_COMBAT_STATE_UPDATE.value] = (
+            handle_event_in_combat_state_update
+        )
+
+        self.event_handler[EventCode.UPDATE_FAME.value] = handle_event_update_fame
+        self.event_handler[EventCode.UPDATE_RE_SPEC_POINTS.value] = (
+            handle_event_update_re_spec_points
+        )
+        self.event_handler[EventCode.OTHER_GRABBED_LOOT.value] = (
+            handle_event_other_grabbed_loot
+        )
+        self.event_handler[EventCode.PARTY_JOINED.value] = handle_event_party_joined
+        self.event_handler[EventCode.PARTY_DISBANDED.value] = (
+            handle_event_party_disbanded
+        )
+        self.event_handler[EventCode.PARTY_PLAYER_JOINED.value] = (
+            handle_event_party_player_joined
+        )
+        self.event_handler[EventCode.PARTY_PLAYER_LEFT.value] = (
+            handle_event_party_player_left
+        )
+        self.event_handler[EventCode.CHARACTER_EQUIPMENT_CHANGED.value] = (
+            handle_event_character_equipment_changed
+        )
+
+        # Request Handler
+        self.request_handler[OperationCode.MOVE.value] = handle_operation_move
+
+        # Response Handler
+        self.response_handler[OperationCode.JOIN.value] = handle_operation_join
+        self.response_handler[OperationCode.CHANGE_CLUSTER.value] = (
+            handle_operation_change_cluster
+        )
+
+    def on_request(self, world_data: WorldData, parameters):
+        if REQUEST_TYPE_PARAMETER not in parameters:
+            return None
+
+        if parameters[REQUEST_TYPE_PARAMETER] not in self.request_handler:
+            return None
+
+        handler = self.request_handler[parameters[REQUEST_TYPE_PARAMETER]]
+        return handler(world_data, parameters)
+
+    def on_response(self, world_data: WorldData, parameters):
+        if RESPONSE_TYPE_PARAMETER not in parameters:
+            return None
+
+        if parameters[RESPONSE_TYPE_PARAMETER] not in self.response_handler:
+            return None
+
+        handler = self.response_handler[parameters[RESPONSE_TYPE_PARAMETER]]
+        return handler(world_data, parameters)
+
+    def on_event(self, world_data: WorldData, parameters):
+        if EVENT_TYPE_PARAMETER not in parameters:
+            return None
+
+        if parameters[EVENT_TYPE_PARAMETER] not in self.event_handler:
+            return None
+
+        handler = self.event_handler[parameters[EVENT_TYPE_PARAMETER]]
+        return handler(world_data, parameters)

albibong-1.0.6/src/albibong/classes/event_handler/handle_event_character_equipment_changed.py

@@ -0,0 +1,24 @@
+from albibong.classes.world_data import WorldData
+from albibong.threads.websocket_server import send_event
+
+
+def handle_event_character_equipment_changed(world_data: WorldData, parameters):
+    if 2 in parameters:
+        if parameters[0] in world_data.char_id_to_username:
+            if world_data.char_id_to_username[parameters[0]] != "not initialized":
+                char = world_data.characters[
+                    world_data.char_id_to_username[parameters[0]]
+                ]
+                if char.username in world_data.party_members:
+                    char.update_equipment(parameters[2])
+                    ws_update_character_equipment(world_data)
+        else:
+            world_data.change_equipment_log[parameters[0]] = parameters[2]
+
+
+def ws_update_character_equipment(world_data: WorldData):
+    event = {
+        "type": "update_dps",
+        "payload": {"party_members": world_data.serialize_party_members()},
+    }
+    send_event(event)

albibong-1.0.6/src/albibong/classes/event_handler/handle_event_health.py

@@ -0,0 +1,35 @@
+from albibong.classes.character import Character
+from albibong.classes.event_handler.world_data_utils import WorldDataUtils
+from albibong.classes.world_data import WorldData
+from albibong.threads.websocket_server import send_event
+
+
+def handle_event_health_update(world_data: WorldData, parameters):
+
+    if world_data.is_dps_meter_running == False:
+        return
+
+    if 0 not in parameters or 6 not in parameters or 2 not in parameters:
+        return
+
+    nominal = parameters[2]
+    target = parameters[0]
+    inflictor = parameters[6]
+
+    WorldDataUtils.update_damage_or_heal(world_data, target, inflictor, nominal)
+
+
+def handle_event_health_updates(world_data: WorldData, parameters):
+
+    if world_data.is_dps_meter_running == False:
+        return
+
+    if 0 not in parameters or 6 not in parameters or 2 not in parameters:
+        return
+
+    for i in range(len(parameters[2])):
+        nominal = parameters[2][i]
+        target = parameters[0]
+        inflictor = parameters[6][i]
+
+        WorldDataUtils.update_damage_or_heal(world_data, target, inflictor, nominal)

albibong-1.0.6/src/albibong/classes/event_handler/handle_event_in_combat_state_update.py

@@ -0,0 +1,17 @@
+from albibong.classes.character import Character
+from albibong.classes.world_data import WorldData
+
+
+def handle_event_in_combat_state_update(world_data: WorldData, parameters):
+
+    if parameters[0] not in world_data.char_id_to_username:
+        # character not initialized
+        return
+
+    name = world_data.char_id_to_username[parameters[0]]
+    char: Character = world_data.characters[name]
+
+    if 1 in parameters:
+        char.update_combat_duration(True)
+    else:
+        char.update_combat_duration(False)

albibong-1.0.6/src/albibong/classes/event_handler/handle_event_new_character.py

@@ -0,0 +1,44 @@
+from albibong.classes.character import Character
+from albibong.classes.coords import Coords
+from albibong.classes.event_handler.world_data_utils import WorldDataUtils
+from albibong.classes.utils import Utils
+from albibong.classes.world_data import WorldData
+
+
+def handle_event_new_character(world_data: WorldData, parameters):
+
+    id = parameters[0]
+    uuid = parameters[7]
+    username = parameters[1]
+    guild = parameters[8] if 8 in parameters else ""
+    alliance = parameters[49] if 49 in parameters else ""
+    coords = (
+        Coords(parameters[15][0], parameters[15][1])
+        if 15 in parameters
+        else Coords(0, 0)
+    )
+    equipments = parameters[38] if 38 in parameters else []
+
+    # initiate character
+    if username not in world_data.characters:
+        char: Character = Character(
+            id=id,
+            uuid=Utils.convert_int_arr_to_uuid(uuid),
+            username=username,
+            guild=guild,
+            alliance=alliance,
+            coords=coords,
+        )
+        char.update_equipment(equipments)
+        world_data.characters[char.username] = char
+        world_data.char_id_to_username[char.id] = char.username
+        world_data.char_uuid_to_username[char.uuid] = char.username
+
+    # change map
+    else:
+        char: Character = world_data.characters[username]
+        char.update_equipment(equipments)
+        char.coords = coords
+        WorldDataUtils.convert_id_to_name(
+            world_data, old_id=char.id, new_id=id, char=char
+        )

albibong-1.0.6/src/albibong/classes/event_handler/handle_event_other_grabbed_loot.py

@@ -0,0 +1,14 @@
+from albibong.classes.character import Character
+from albibong.classes.world_data import WorldData
+
+
+def handle_event_other_grabbed_loot(world_data: WorldData, parameters):
+
+    # update char data
+    if 2 in parameters and parameters[2] in world_data.characters:
+        char: Character = world_data.characters[parameters[2]]
+        char.update_loot(parameters)
+
+    # update dungeon data
+    if world_data.current_dungeon and parameters[2] == world_data.me.username:
+        world_data.current_dungeon.update_loot(parameters)

albibong-1.0.6/src/albibong/classes/event_handler/handle_event_party.py

@@ -0,0 +1,38 @@
+from uuid import UUID
+from albibong.classes.world_data import WorldData
+from albibong.threads.websocket_server import send_event
+
+
+def handle_event_party_joined(world_data: WorldData, parameters):
+    world_data.party_members = set(parameters[5])
+    ws_update_party_member(world_data)
+
+
+def handle_event_party_disbanded(world_data: WorldData, parameters):
+    world_data.party_members = {world_data.me.username}
+    ws_update_party_member(world_data)
+
+
+def handle_event_party_player_joined(world_data: WorldData, parameters):
+    world_data.party_members.add(parameters[2])
+    ws_update_party_member(world_data)
+
+
+def handle_event_party_player_left(world_data: WorldData, parameters):
+    uuid = UUID(bytes=bytes(parameters[1]))
+
+    if uuid in world_data.char_uuid_to_username:
+        name = world_data.char_uuid_to_username[uuid]
+
+        # self out party
+        if name == world_data.me.username:
+            world_data.party_members = {world_data.me.username}
+            ws_update_party_member(world_data)
+
+
+def ws_update_party_member(world_data: WorldData):
+    event = {
+        "type": "update_dps",
+        "payload": {"party_members": world_data.serialize_party_members()},
+    }
+    send_event(event)

albibong-1.0.6/src/albibong/classes/event_handler/handle_event_update_fame.py

@@ -0,0 +1,7 @@
+from albibong.classes.world_data import WorldData
+
+
+def handle_event_update_fame(world_data: WorldData, parameters):
+    world_data.me.update_fame(parameters)
+    if world_data.current_dungeon:
+        world_data.current_dungeon.update_fame(parameters)

albibong-1.0.6/src/albibong/classes/event_handler/handle_event_update_re_spec_points.py

@@ -0,0 +1,11 @@
+from albibong.classes.world_data import WorldData
+
+
+def handle_event_update_re_spec_points(world_data: WorldData, parameters):
+
+    # update char data
+    world_data.me.update_re_spec(parameters)
+
+    # update dungeon data
+    if world_data.current_dungeon:
+        world_data.current_dungeon.update_re_spec(parameters)

albibong-1.0.6/src/albibong/classes/event_handler/handle_operation_change_cluster.py

@@ -0,0 +1,43 @@
+from albibong.classes.event_handler.world_data_utils import WorldDataUtils
+from albibong.classes.location import Location
+from albibong.classes.world_data import WorldData
+from albibong.threads.websocket_server import send_event
+
+
+def handle_operation_change_cluster(world_data: WorldData, parameters):
+    world_data.change_equipment_log = {}
+
+    if 1 in parameters:
+        check_map = Location.get_location_from_code(parameters[1])
+        map_type_splitted = set(check_map.type.split("_"))
+        WorldDataUtils.set_dungeon_status(world_data, check_map, map_type_splitted)
+
+        if "ISLAND" in map_type_splitted or "HIDEOUT" in map_type_splitted:
+            check_map.name = f"{parameters[2]}'s {check_map.name}"
+            world_data.current_map = check_map
+
+    elif 0 in parameters:
+        check_map = Location.get_location_from_code(parameters[0])
+        map_type_splitted = set(check_map.type.split("_"))
+        is_dungeon = WorldDataUtils.set_dungeon_status(
+            world_data, check_map, map_type_splitted
+        )
+        if is_dungeon == False:
+            world_data.current_map = Location.get_location_from_code(parameters[0])
+
+    ws_update_location(world_data)
+
+
+def ws_update_location(world_data: WorldData):
+    event = {
+        "type": "update_location",
+        "payload": {
+            "map": world_data.current_map.name if world_data.current_map else "None",
+            "dungeon": (
+                world_data.current_dungeon.name
+                if world_data.current_dungeon
+                else "None"
+            ),
+        },
+    }
+    send_event(event)

albibong-1.0.6/src/albibong/classes/event_handler/handle_operation_join.py

@@ -0,0 +1,78 @@
+from albibong.classes.dungeon import Dungeon
+from albibong.classes.event_handler.world_data_utils import WorldDataUtils
+from albibong.classes.location import Location
+from albibong.classes.utils import Utils
+from albibong.classes.world_data import WorldData
+from albibong.threads.websocket_server import send_event
+
+
+def handle_operation_join(world_data: WorldData, parameters):
+    # set my character
+    WorldDataUtils.convert_id_to_name(
+        world_data, old_id=world_data.me.id, new_id=parameters[0], char=world_data.me
+    )
+    world_data.me.uuid = Utils.convert_int_arr_to_uuid(parameters[1])
+    world_data.me.username = parameters[2]
+    world_data.me.guild = parameters[57] if 57 in parameters else ""
+    world_data.me.alliance = parameters[77] if 77 in parameters else ""
+    if world_data.me.id in world_data.change_equipment_log:
+        world_data.me.update_equipment(
+            world_data.change_equipment_log[world_data.me.id]
+        )
+
+    # put self in characters list
+    world_data.characters[world_data.me.username] = world_data.me
+    world_data.char_uuid_to_username[world_data.me.uuid] = world_data.me.username
+
+    # put self in party
+    world_data.party_members.add(world_data.me.username)
+
+    # set map my character is currently in
+    if parameters[8][0] == "@":
+        area = parameters[8].split("@")
+        if area[1] == "RANDOMDUNGEON":
+            check_map = Location.get_location_from_code(area[1])
+            WorldDataUtils.start_current_dungeon(
+                world_data, type=check_map.type, name=check_map.name
+            )
+
+    ws_init_character(world_data)
+    ws_update_location(world_data)
+    ws_update_dps(world_data)
+
+
+def ws_init_character(world_data: WorldData):
+    event = {
+        "type": "init_character",
+        "payload": {
+            "username": world_data.me.username,
+            "fame": world_data.me.fame_gained,
+            "re_spec": world_data.me.re_spec_gained,
+            "silver": world_data.me.silver_gained,
+            "weapon": world_data.me.equipment[0].image,
+        },
+    }
+    send_event(event)
+
+
+def ws_update_location(world_data: WorldData):
+    event = {
+        "type": "update_location",
+        "payload": {
+            "map": world_data.current_map.name if world_data.current_map else "None",
+            "dungeon": (
+                Dungeon.serialize(world_data.current_dungeon)
+                if world_data.current_dungeon
+                else None
+            ),
+        },
+    }
+    send_event(event)
+
+
+def ws_update_dps(world_data: WorldData):
+    event = {
+        "type": "update_dps",
+        "payload": {"party_members": world_data.serialize_party_members()},
+    }
+    send_event(event)

albibong-1.0.6/src/albibong/classes/event_handler/handle_operation_move.py

@@ -0,0 +1,8 @@
+from albibong.classes.world_data import WorldData
+
+
+def handle_operation_move(world_data: WorldData, parameters):
+    if not world_data.me:
+        return
+
+    world_data.me.update_coords(parameters)

albibong-1.0.6/src/albibong/classes/event_handler/world_data_utils.py

@@ -0,0 +1,102 @@
+from collections import deque
+import json
+import os
+
+from albibong.classes.character import Character
+from albibong.classes.dungeon import Dungeon
+from albibong.classes.location import Location
+from albibong.classes.utils import Utils
+from albibong.classes.world_data import WorldData
+from albibong.threads.websocket_server import send_event
+
+FILENAME = os.path.join(os.path.expanduser("~"), "Albibong/list_dungeon.json")
+os.makedirs(os.path.dirname(FILENAME), exist_ok=True)
+
+
+class WorldDataUtils:
+
+    def end_current_dungeon(world_data: WorldData):
+        if world_data.current_dungeon:
+            list_dungeon = deque()
+
+            try:
+                with open(FILENAME) as json_file:
+                    list_dungeon = deque(json.load(json_file))
+            except:
+                pass
+
+            world_data.current_dungeon.get_elapsed_time()
+            list_dungeon.appendleft(Dungeon.serialize(world_data.current_dungeon))
+
+            with open(FILENAME, "w") as json_file:
+                json.dump(list(list_dungeon), json_file)
+
+            WorldDataUtils.ws_update_dungeon(list(list_dungeon))
+
+            world_data.current_dungeon = None
+
+    def ws_update_dungeon(list_dungeon: list):
+        event = {
+            "type": "update_dungeon",
+            "payload": {"list_dungeon": list_dungeon},
+        }
+        send_event(event)
+
+    @staticmethod
+    def start_current_dungeon(world_data: WorldData, type: str, name: str):
+        if world_data.current_dungeon == None:
+            new_dungeon = Dungeon(type, name)
+            world_data.current_dungeon = new_dungeon
+
+    @staticmethod
+    def set_dungeon_status(
+        world_data: WorldData, check_map: Location, map_type_splitted: set
+    ):
+        if "EXPEDITION" in map_type_splitted or "DUNGEON" in map_type_splitted:
+            WorldDataUtils.start_current_dungeon(
+                world_data, type=check_map.type, name=check_map.name
+            )
+        elif (
+            "EXPEDITION" not in map_type_splitted or "DUNGEON" not in map_type_splitted
+        ):
+            WorldDataUtils.end_current_dungeon(world_data)
+            return False
+
+    @staticmethod
+    def convert_id_to_name(world_data: WorldData, old_id, new_id, char: Character):
+        if old_id in world_data.char_id_to_username:
+            world_data.char_id_to_username.pop(old_id)  # delete old relative id
+        char.id = new_id
+        world_data.char_id_to_username[char.id] = char.username  # add new relative id
+
+    @staticmethod
+    def update_damage_or_heal(world_data: WorldData, target, inflictor, nominal):
+
+        if inflictor not in world_data.char_id_to_username:
+            # character not initialized yet
+            return
+
+        username = world_data.char_id_to_username[inflictor]
+
+        if username == "not initialized":
+            # self not initialized
+            return
+
+        char: Character = world_data.characters[username]
+
+        if nominal < 0:
+            if target == inflictor:
+                # suicide
+                return
+            char.update_damage_dealt(abs(nominal))
+        else:
+            char.update_heal_dealt(nominal)
+
+        WorldDataUtils.ws_update_damage_heal(world_data)
+
+    def ws_update_damage_heal(world_data: WorldData):
+        event = {
+            "type": "update_dps",
+            "payload": {"party_members": world_data.serialize_party_members()},
+        }
+        send_event(event)