albibong 1.0.7__tar.gz → 1.1.1__tar.gz

{albibong-1.0.7 → albibong-1.1.1}/.gitignore

@@ -7,6 +7,8 @@ dump/
 log/
 pcap/
 .vscode
+src/*.db
+*.db
 
 ### macOS ###
 # General

{albibong-1.0.7 → albibong-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: albibong
-Version: 1.0.7
+Version: 1.1.1
 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
@@ -10,6 +10,8 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
+Requires-Dist: peewee-migrate==1.13.0
+Requires-Dist: peewee==3.17.6
 Requires-Dist: pywebview==5.1
 Requires-Dist: scapy==2.5.0
 Requires-Dist: websockets==12.0

{albibong-1.0.7 → albibong-1.1.1}/pyproject.toml

@@ -11,7 +11,8 @@ exclude = [
   "/tests",
   "/gui",
   "/readme_screenshots",
-  "/README.md"
+  "/README.md",
+  "/*.db"
 ]
 
 [project.scripts]
@@ -19,7 +20,7 @@ albibong = "albibong:main"
 
 [project]
 name = "albibong"
-version = "1.0.7"
+version = "1.1.1"
 authors = [
   { name="imjangkar", email="imjangkar@gmail.com" },
 ]
@@ -34,6 +35,8 @@ dependencies = [
   "scapy==2.5.0",
   "websockets==12.0",
   "pywebview==5.1",
+  "peewee==3.17.6",
+  "peewee-migrate==1.13.0",
 ]
 
 [project.urls]

albibong-1.1.1/src/albibong/__init__.py

@@ -0,0 +1,173 @@
+import json
+import os
+import queue
+import random
+import socket
+import sys
+import uuid
+from datetime import datetime, timedelta
+from pathlib import Path
+from time import sleep
+
+import webview
+from peewee_migrate import Router
+from scapy.all import rdpcap
+
+from albibong.classes.logger import Logger
+from albibong.classes.packet_handler import PacketHandler
+from albibong.classes.utils import Utils
+from albibong.models.models import SQLITE_DB, db
+from albibong.threads.http_server import HttpServerThread
+from albibong.threads.packet_handler_thread import PacketHandlerThread
+from albibong.threads.sniffer_thread import SnifferThread
+from albibong.threads.websocket_server import get_ws_server
+
+logger = Logger(__name__, stdout=True, log_to_file=False)
+PORT = random.randrange(8500, 8999)
+
+home_dir = os.path.expanduser("~")
+DUNGEON_JSON = f"{home_dir}/Albibong/list_dungeon.json"
+
+current_path = os.path.dirname(__file__)
+MIGRATION_FOLDER = os.path.join(current_path, f"migrations")
+
+
+def read_pcap(path):
+    packet_handler = PacketHandler()
+    scapy_cap = rdpcap(path)
+    for packet in scapy_cap:
+        packet_handler.handle(packet)
+
+
+def get_dungeon_end_time(str, start_time):
+    timer = str.split(":")
+    seconds = int(timer[0]) * 3600 + int(timer[1]) * 60 + int(timer[2])
+    return timedelta(seconds=seconds) + start_time
+
+
+def check_db_validity():
+    migrate = Router(db, migrate_dir=MIGRATION_FOLDER)
+
+    if Path(SQLITE_DB).is_file() == False:
+        if Path(DUNGEON_JSON).is_file() == True:
+
+            migrate.run("001_init")
+
+            # convert json db to sqlite db
+            json_data = json.load(open(DUNGEON_JSON))
+
+            for dungeon in json_data:
+                start_time = datetime.strptime(
+                    dungeon["date_time"], "%a %d %b %Y, %I:%M%p"
+                )
+                type_splitted = set(dungeon["type"].split("_"))
+
+                if "CORRUPTED" in type_splitted:
+                    converted_type = "CORRUPTED DUNGEON"
+                elif "HARDCORE" in type_splitted:
+                    converted_type = "HARDCORE EXPEDITION"
+                elif "10V10" in type_splitted:
+                    converted_type = "HELLGATE 10V10"
+                elif "5V5" in type_splitted:
+                    converted_type = "HELLGATE 5V5"
+                elif "2V2" in type_splitted:
+                    converted_type = "HELLGATE 2V2"
+                elif "DUNGEON" in type_splitted:
+                    converted_type = "STATIC DUNGEON"
+                elif "RANDOMDUNGEON" in type_splitted:
+                    converted_type = "SPAWN DUNGEON"
+
+                asd = [
+                    ("id", str(uuid.uuid4())),
+                    ("type", f"{converted_type}"),
+                    ("name", f'{dungeon["name"]}'),
+                    ("tier", f'{dungeon["tier"]}'),
+                    ("fame", f'{dungeon["fame"]}'),
+                    ("silver", f'{dungeon["silver"]}'),
+                    ("re_spec", f'{dungeon["re_spec"]}'),
+                    ("start_time", f"{start_time}"),
+                    (
+                        "end_time",
+                        f'{get_dungeon_end_time(dungeon["time_elapsed"], start_time)}',
+                    ),
+                    ("meter", ""),
+                ]
+
+                columns = ", ".join([x[0] for x in asd])
+                values = ", ".join([f'"{x[1]}"' for x in asd])
+                sql_query = f"INSERT INTO dungeon ({columns}) VALUES ({values})"
+
+                db.execute_sql(sql_query)
+
+    migrate.run()
+
+
+def sniff(useWebview, is_debug=False):
+
+    check_db_validity()
+
+    _sentinel = object()
+    packet_queue = queue.Queue()
+
+    p = SnifferThread(
+        name="sniffer", out_queue=packet_queue, sentinel=_sentinel, is_debug=is_debug
+    )
+    c = PacketHandlerThread(
+        name="packet_handler",
+        in_queue=packet_queue,
+        sentinel=_sentinel,
+    )
+
+    p.start()
+    c.start()
+
+    ws_server = get_ws_server()
+    ws_server.start()
+
+    if useWebview:
+        sock = socket.socket()
+        sock.bind(("", 0))
+        port = sock.getsockname()[1]
+        sock.close()
+
+        http_server = HttpServerThread(name="http_server", port=port)
+        http_server.start()
+
+        window = webview.create_window(
+            "Albibong",
+            url=f"http://localhost:{port}/",
+            width=1280,
+            height=720,
+            zoomable=True,
+        )
+
+        def on_closing():
+            c.stop()
+            p.stop()
+            ws_server.stop()
+            http_server.stop()
+            db.close()
+
+        window.events.closing += on_closing
+
+        webview.start()
+    else:
+        try:
+            while True:
+                sleep(100)
+        except KeyboardInterrupt as e:
+            p.stop()
+            ws_server.stop()
+
+
+def main(useWebview=True):
+    if len(sys.argv) > 1:
+        if sys.argv[-1] == "--debug":
+            Utils.get_user_specifications("pip")
+            sniff(useWebview, is_debug=True)
+        else:
+            ws_server = get_ws_server()
+            ws_server.start()
+            read_pcap(sys.argv[1])
+    else:
+        sniff(useWebview)

{albibong-1.0.7 → albibong-1.1.1}/src/albibong/__main__.py

@@ -1,6 +1,12 @@
+import sys
+
 from albibong import main
 from albibong.classes.logger import use_logger
+from albibong.classes.utils import Utils
 
 if __name__ == "__main__":
     use_logger(True)
+
+    if sys.argv[-1] == "--debug":
+        Utils.get_user_specifications("source code")
     main(useWebview=False)

{albibong-1.0.7 → albibong-1.1.1}/src/albibong/classes/character.py

@@ -1,10 +1,9 @@
-from datetime import datetime, timedelta
 import json
+from datetime import datetime, timedelta
 from uuid import UUID
 
 from albibong.classes.coords import Coords
 from albibong.classes.item import Item
-from albibong.threads.websocket_server import send_event
 
 DIVISOR = 10000
 
@@ -35,6 +34,8 @@ class Character:
         self.re_spec_gained: int = 0
         self.silver_gained: int = 0
         self.loot: list[str] = []
+        self.might_gained: int = 0
+        self.favor_gained: int = 0
 
         # Combat
         self.damage_dealt: int = 0
@@ -69,37 +70,16 @@ class Character:
     def update_fame(self, parameters):
         fame = parameters[2] / DIVISOR
         self.fame_gained += fame
-        event = {
-            "type": "update_fame",
-            "payload": {"username": self.username, "fame_gained": self.fame_gained},
-        }
-        send_event(event)
 
     def update_re_spec(self, parameters):
         re_spec = parameters[2] / DIVISOR
         self.re_spec_gained += re_spec
-        event = {
-            "type": "update_re_spec",
-            "payload": {
-                "username": self.username,
-                "re_spec_gained": self.re_spec_gained,
-            },
-        }
-        send_event(event)
 
     def update_loot(self, parameters):
         if 3 in parameters and parameters[3] == True:
             if 5 in parameters:
                 silver = parameters[5] / DIVISOR
                 self.silver_gained += silver
-                event = {
-                    "type": "update_silver",
-                    "payload": {
-                        "username": self.username,
-                        "silver_gained": self.silver_gained,
-                    },
-                }
-                send_event(event)
         else:
             self.loot.append(parameters[4])
 
@@ -110,3 +90,7 @@ class Character:
                 obj = Item.get_item_from_code(str(eq))
                 new_eq.append(obj)
         self.equipment = new_eq
+
+    def update_might_and_favor(self, parameters):
+        self.favor_gained += parameters[4] / DIVISOR
+        self.might_gained += parameters[1] / DIVISOR

albibong-1.1.1/src/albibong/classes/dungeon.py

@@ -0,0 +1,80 @@
+import uuid
+from datetime import datetime
+
+from peewee import *
+from playhouse.sqlite_ext import JSONField
+
+from albibong.models.models import BaseModel
+
+DIVISOR = 10000
+
+
+class Dungeon(BaseModel):
+
+    id = UUIDField(unique=True, default=uuid.uuid4)
+    type = CharField()
+    name = CharField()
+    tier = FloatField(default=0)
+    fame = FloatField(default=0)
+    silver = FloatField(default=0)
+    re_spec = FloatField(default=0)
+    might = FloatField(default=0)
+    favor = FloatField(default=0)
+    start_time = DateTimeField(default=datetime.now)
+    end_time = DateTimeField(null=True, default=None)
+    meter = JSONField(default=dict)
+
+    @staticmethod
+    def serialize(dungeon):
+        time_elapsed = dungeon.end_time - dungeon.start_time
+        total_hours = time_elapsed.total_seconds() / 3600
+
+        return {
+            "id": str(dungeon.id),
+            "type": dungeon.type,
+            "name": dungeon.name,
+            "tier": dungeon.tier,
+            "fame": dungeon.fame,
+            "fame_per_hour": dungeon.fame / total_hours,
+            "silver": dungeon.silver,
+            "silver_per_hour": dungeon.silver / total_hours,
+            "re_spec": dungeon.re_spec,
+            "re_spec_per_hour": dungeon.re_spec / total_hours,
+            "might": dungeon.might,
+            "might_per_hour": dungeon.might / total_hours,
+            "favor": dungeon.favor,
+            "favor_per_hour": dungeon.favor / total_hours,
+            "date_time": dungeon.start_time.strftime("%a %d %b %Y, %I:%M%p"),
+            "time_elapsed": (
+                str(time_elapsed).split(".")[0] if dungeon.end_time else ""
+            ),
+            "meter": dungeon.meter,
+        }
+
+    def set_end_time(self):
+        self.end_time = datetime.now()
+
+    def update_fame(self, parameters):
+        fame = parameters[2] / DIVISOR
+        self.fame += fame
+
+    def update_re_spec(self, parameters):
+        re_spec = parameters[2] / DIVISOR
+        self.re_spec += re_spec
+
+    def update_might_and_favor(self, parameters):
+        self.favor += parameters[4] / DIVISOR
+        self.might += parameters[1] / DIVISOR
+
+    def update_loot(self, parameters):
+        if 3 in parameters and parameters[3] == True:
+            silver = parameters[5] / DIVISOR
+            self.silver += silver
+
+    def update_meter(self, party):
+        self.meter = party
+
+    @staticmethod
+    def get_all_dungeon():
+        query = Dungeon.select().order_by(Dungeon.start_time.desc())
+        return [Dungeon.serialize(dungeon) for dungeon in query]

{albibong-1.0.7 → albibong-1.1.1}/src/albibong/classes/event_handler/__init__.py

@@ -8,6 +8,9 @@ from albibong.classes.event_handler.handle_event_health import (
 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_might_and_favor_received_event import (
+    handle_event_might_and_favor_received_event,
+)
 from albibong.classes.event_handler.handle_event_new_character import (
     handle_event_new_character,
 )
@@ -29,13 +32,16 @@ from albibong.classes.event_handler.handle_event_update_re_spec_points import (
 from albibong.classes.event_handler.handle_operation_change_cluster import (
     handle_operation_change_cluster,
 )
+from albibong.classes.event_handler.handle_operation_farmable_harvest import (
+    handle_operation_farmable_finish_grown_item,
+    handle_operation_farmable_harvest,
+)
 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
@@ -59,6 +65,10 @@ class EventHandler:
         self.event_handler[EventCode.UPDATE_RE_SPEC_POINTS.value] = (
             handle_event_update_re_spec_points
         )
+        self.event_handler[EventCode.MIGHT_AND_FAVOR_RECEIVED_EVENT.value] = (
+            handle_event_might_and_favor_received_event
+        )
+
         self.event_handler[EventCode.OTHER_GRABBED_LOOT.value] = (
             handle_event_other_grabbed_loot
         )
@@ -84,6 +94,12 @@ class EventHandler:
         self.response_handler[OperationCode.CHANGE_CLUSTER.value] = (
             handle_operation_change_cluster
         )
+        self.response_handler[OperationCode.FARMABLE_FINISH_GROWN_ITEM.value] = (
+            handle_operation_farmable_finish_grown_item
+        )
+        self.response_handler[OperationCode.FARMABLE_HARVEST.value] = (
+            handle_operation_farmable_harvest
+        )
 
     def on_request(self, world_data: WorldData, parameters):
         if REQUEST_TYPE_PARAMETER not in parameters:

{albibong-1.0.7 → albibong-1.1.1}/src/albibong/classes/event_handler/handle_event_character_equipment_changed.py

@@ -1,5 +1,5 @@
+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_character_equipment_changed(world_data: WorldData, parameters):
@@ -11,14 +11,6 @@ def handle_event_character_equipment_changed(world_data: WorldData, parameters):
                 ]
                 if char.username in world_data.party_members:
                     char.update_equipment(parameters[2])
-                    ws_update_character_equipment(world_data)
+                    WorldDataUtils.ws_update_damage_meter(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.1.1/src/albibong/classes/event_handler/handle_event_might_and_favor_received_event.py

@@ -0,0 +1,18 @@
+from albibong.classes.world_data import WorldData
+from albibong.threads.websocket_server import send_event
+
+
+def handle_event_might_and_favor_received_event(world_data: WorldData, parameters):
+    world_data.me.update_might_and_favor(parameters)
+    event = {
+        "type": "update_might_and_favor",
+        "payload": {
+            "username": world_data.me.username,
+            "favor_gained": world_data.me.favor_gained,
+            "might_gained": world_data.me.might_gained,
+        },
+    }
+    send_event(event)
+
+    if world_data.current_dungeon:
+        world_data.current_dungeon.update_might_and_favor(parameters)

{albibong-1.0.7 → albibong-1.1.1}/src/albibong/classes/event_handler/handle_event_other_grabbed_loot.py

@@ -1,5 +1,6 @@
 from albibong.classes.character import Character
 from albibong.classes.world_data import WorldData
+from albibong.threads.websocket_server import send_event
 
 
 def handle_event_other_grabbed_loot(world_data: WorldData, parameters):
@@ -8,6 +9,14 @@ def handle_event_other_grabbed_loot(world_data: WorldData, parameters):
     if 2 in parameters and parameters[2] in world_data.characters:
         char: Character = world_data.characters[parameters[2]]
         char.update_loot(parameters)
+        event = {
+            "type": "update_silver",
+            "payload": {
+                "username": char.username,
+                "silver_gained": char.silver_gained,
+            },
+        }
+        send_event(event)
 
     # update dungeon data
     if world_data.current_dungeon and parameters[2] == world_data.me.username:

{albibong-1.0.7 → albibong-1.1.1}/src/albibong/classes/event_handler/handle_event_party.py

@@ -1,21 +1,22 @@
 from uuid import UUID
+
+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_party_joined(world_data: WorldData, parameters):
     world_data.party_members = set(parameters[5])
-    ws_update_party_member(world_data)
+    WorldDataUtils.ws_update_damage_meter(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)
+    WorldDataUtils.ws_update_damage_meter(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)
+    WorldDataUtils.ws_update_damage_meter(world_data)
 
 
 def handle_event_party_player_left(world_data: WorldData, parameters):
@@ -27,12 +28,4 @@ def handle_event_party_player_left(world_data: WorldData, parameters):
         # 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)
+            WorldDataUtils.ws_update_damage_meter(world_data)

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

@@ -0,0 +1,16 @@
+from albibong.classes.world_data import WorldData
+from albibong.threads.websocket_server import send_event
+
+
+def handle_event_update_fame(world_data: WorldData, parameters):
+    world_data.me.update_fame(parameters)
+    event = {
+        "type": "update_fame",
+        "payload": {
+            "username": world_data.me.username,
+            "fame_gained": world_data.me.fame_gained,
+        },
+    }
+    send_event(event)
+    if world_data.current_dungeon:
+        world_data.current_dungeon.update_fame(parameters)

{albibong-1.0.7 → albibong-1.1.1}/src/albibong/classes/event_handler/handle_event_update_re_spec_points.py

@@ -1,10 +1,19 @@
 from albibong.classes.world_data import WorldData
+from albibong.threads.websocket_server import send_event
 
 
 def handle_event_update_re_spec_points(world_data: WorldData, parameters):
 
     # update char data
     world_data.me.update_re_spec(parameters)
+    event = {
+        "type": "update_re_spec",
+        "payload": {
+            "username": world_data.me.username,
+            "re_spec_gained": world_data.me.re_spec_gained,
+        },
+    }
+    send_event(event)
 
     # update dungeon data
     if world_data.current_dungeon:

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

@@ -0,0 +1,38 @@
+from albibong.classes.event_handler.world_data_utils import WorldDataUtils
+from albibong.classes.location import Island, 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 type(world_data.current_map).__name__ == "Island":
+        WorldDataUtils.set_island_status(
+            current_island=world_data.current_map, parameters=parameters
+        )
+
+    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:
+            island = Island.get_island_from_code(parameters[1])
+            island.name = f"{parameters[2]}'s {island.name}"
+            world_data.current_map = island
+        elif "HIDEOUT" in map_type_splitted:
+            hideout = Location.get_location_from_code(parameters[1])
+            hideout.name = f"{parameters[2]}'s {hideout.name}"
+            world_data.current_map = hideout
+
+    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])
+
+    WorldDataUtils.ws_update_location(world_data)

albibong-1.1.1/src/albibong/classes/event_handler/handle_operation_farmable_harvest.py

@@ -0,0 +1,17 @@
+from albibong.classes.world_data import WorldData
+
+
+def handle_operation_farmable_harvest(world_data: WorldData, parameters):
+    if type(world_data.current_map).__name__ == "Island":
+        for i in range(len(parameters[0])):
+            world_data.current_map.add_crop(
+                unique_name=parameters[0][i], quantity=parameters[1][i]
+            )
+
+
+def handle_operation_farmable_finish_grown_item(world_data: WorldData, parameters):
+    if type(world_data.current_map).__name__ == "Island":
+        for i in range(len(parameters[0])):
+            world_data.current_map.add_animal(
+                unique_name=parameters[0][i], quantity=parameters[1][i]
+            )