albibong 1.0.6__tar.gz → 1.1.0__tar.gz

{albibong-1.0.6 → albibong-1.1.0}/.gitignore

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: albibong
-Version: 1.0.6
+Version: 1.1.0
 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,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
+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.6 → albibong-1.1.0}/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.6"
+version = "1.1.0"
 authors = [
   { name="imjangkar", email="imjangkar@gmail.com" },
 ]
@@ -34,6 +35,7 @@ dependencies = [
   "scapy==2.5.0",
   "websockets==12.0",
   "pywebview==5.1",
+  "peewee==3.17.6",
 ]
 
 [project.urls]

albibong-1.1.0/src/albibong/__init__.py

@@ -0,0 +1,147 @@
+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 scapy.all import rdpcap
+
+from albibong.classes.dungeon import Dungeon
+from albibong.classes.location import Island
+from albibong.classes.logger import Logger
+from albibong.classes.packet_handler import PacketHandler
+from albibong.models.models import 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_DB = f"{home_dir}/Albibong/list_dungeon.json"
+SQLITE_DB = f"{home_dir}/Albibong/Albibong.db"
+
+
+def read_pcap(path):
+    packet_handler = PacketHandler()
+    scapy_cap = rdpcap(path)
+    for packet in scapy_cap:
+        packet_handler.handle(packet)
+
+
+def sniff(useWebview):
+    _sentinel = object()
+    packet_queue = queue.Queue()
+
+    p = SnifferThread(name="sniffer", out_queue=packet_queue, sentinel=_sentinel)
+
+    c = PacketHandlerThread(
+        name="packet_handler",
+        in_queue=packet_queue,
+        sentinel=_sentinel,
+    )
+
+    p.start()
+    c.start()
+
+    ws_server = get_ws_server()
+    ws_server.start()
+
+    def get_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
+
+    if Path(SQLITE_DB).is_file() == False:
+        db.connect()
+        db.create_tables([Dungeon, Island])
+        if Path(DUNGEON_DB).is_file() == True:
+            # convert json db to sqlite db
+            json_data = json.load(open(DUNGEON_DB))
+
+            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"
+                Dungeon.create(
+                    type=converted_type,
+                    name=dungeon["name"],
+                    tier=dungeon["tier"],
+                    fame=dungeon["fame"],
+                    silver=dungeon["silver"],
+                    re_spec=dungeon["re_spec"],
+                    start_time=start_time,
+                    end_time=get_end_time(dungeon["time_elapsed"], start_time),
+                )
+
+    db.connect(reuse_if_open=True)
+
+    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:
+        ws_server = get_ws_server()
+        ws_server.start()
+
+        read_pcap(sys.argv[1])
+    else:
+        sniff(useWebview)

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

@@ -0,0 +1,66 @@
+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 = IntegerField(default=0)
+    fame = FloatField(default=0)
+    silver = FloatField(default=0)
+    re_spec = FloatField(default=0)
+    start_time = DateTimeField(default=datetime.now)
+    end_time = DateTimeField(null=True, default=None)
+    meter = JSONField(default=dict)
+
+    @staticmethod
+    def serialize(dungeon):
+        return {
+            "id": str(dungeon.id),
+            "type": dungeon.type,
+            "name": dungeon.name,
+            "tier": dungeon.tier,
+            "fame": dungeon.fame,
+            "silver": dungeon.silver,
+            "re_spec": dungeon.re_spec,
+            "date_time": dungeon.start_time.strftime("%a %d %b %Y, %I:%M%p"),
+            "time_elapsed": (
+                str(dungeon.end_time - dungeon.start_time).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_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.6 → albibong-1.1.0}/src/albibong/classes/event_handler/__init__.py

@@ -30,6 +30,10 @@ 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_farmable_harvest import (
+    handle_operation_farmable_harvest,
+    handle_operation_farmable_finish_grown_item,
+)
 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
@@ -84,6 +88,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.6 → albibong-1.1.0}/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.0.6 → albibong-1.1.0}/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.0/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.0/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]
+            )

{albibong-1.0.6 → albibong-1.1.0}/src/albibong/classes/event_handler/handle_operation_join.py

@@ -7,10 +7,16 @@ from albibong.threads.websocket_server import send_event
 
 
 def handle_operation_join(world_data: WorldData, parameters):
+    # update relative id if character has initialized before
+    if world_data.me.username != "not initialized":
+        WorldDataUtils.convert_id_to_name(
+            world_data,
+            old_id=world_data.me.id,
+            new_id=parameters[0],
+            char=world_data.me,
+        )
+
     # 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 ""
@@ -30,15 +36,15 @@ def handle_operation_join(world_data: WorldData, parameters):
     # set map my character is currently in
     if parameters[8][0] == "@":
         area = parameters[8].split("@")
-        if area[1] == "RANDOMDUNGEON":
+        if area[1] == "RANDOMDUNGEON" or area[1] == "MISTS":
             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)
+    WorldDataUtils.ws_update_location(world_data)
+    WorldDataUtils.ws_update_damage_meter(world_data)
 
 
 def ws_init_character(world_data: WorldData):
@@ -53,26 +59,3 @@ def ws_init_character(world_data: WorldData):
         },
     }
     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.1.0/src/albibong/classes/event_handler/world_data_utils.py

@@ -0,0 +1,155 @@
+import json
+import os
+from collections import deque
+from datetime import datetime
+
+from albibong.classes.character import Character
+from albibong.classes.dungeon import Dungeon
+from albibong.classes.location import Island, Location
+from albibong.classes.utils import Utils
+from albibong.classes.world_data import WorldData
+from albibong.threads.websocket_server import send_event
+
+LIST_DUNGEON = os.path.join(os.path.expanduser("~"), "Albibong/list_dungeon.json")
+os.makedirs(os.path.dirname(LIST_DUNGEON), exist_ok=True)
+LIST_ISLAND = os.path.join(os.path.expanduser("~"), "Albibong/list_island.json")
+os.makedirs(os.path.dirname(LIST_ISLAND), exist_ok=True)
+
+
+class WorldDataUtils:
+
+    def save_current_island(current_map: Island):
+        current_map.save(force_insert=True)
+        WorldDataUtils.ws_update_total_harvest_by_date(
+            Island.get_total_harvest_by_date()
+        )
+        WorldDataUtils.ws_update_island(Island.get_all_island())
+
+    def set_island_status(current_island: Island, parameters):
+        check_map = (
+            Location.get_location_from_code(parameters[1])
+            if 1 in parameters
+            else Location.get_location_from_code(parameters[0])
+        )
+        check_map_name = (
+            f"{parameters[2]}'s {check_map.name}" if 2 in parameters else check_map.name
+        )
+        if current_island.name != check_map_name:
+            if current_island.crops != {} or current_island.animals != {}:
+                WorldDataUtils.save_current_island(current_island)
+
+    def ws_update_total_harvest_by_date(payload):
+        event = {
+            "type": "update_total_harvest_by_date",
+            "payload": payload,
+        }
+        send_event(event)
+
+    def ws_update_island(list_island: list):
+        event = {
+            "type": "update_island",
+            "payload": {"list_island": list_island},
+        }
+        send_event(event)
+
+    def end_current_dungeon(world_data: WorldData):
+        if world_data.current_dungeon:
+            world_data.current_dungeon.set_end_time()
+            world_data.current_dungeon.update_meter(
+                world_data.serialize_party_members()
+            )
+            world_data.current_dungeon.save(force_insert=True)
+            WorldDataUtils.ws_update_dungeon(Dungeon.get_all_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=type, name=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 "HELLGATE" in map_type_splitted:
+            WorldDataUtils.start_current_dungeon(
+                world_data, type=check_map.type, name=check_map.name
+            )
+        elif "DUNGEON" in map_type_splitted:
+            WorldDataUtils.start_current_dungeon(
+                world_data,
+                type=check_map.type,
+                name=(
+                    f"{check_map.name} at {world_data.current_map.name}"
+                    if world_data.current_map
+                    else 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_meter(world_data)
+
+    def ws_update_damage_meter(world_data: WorldData):
+        event = {
+            "type": "update_damage_meter",
+            "payload": {"party_members": world_data.serialize_party_members()},
+        }
+        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": (
+                    world_data.current_dungeon.name
+                    if world_data.current_dungeon
+                    else "None"
+                ),
+            },
+        }
+        send_event(event)

{albibong-1.0.6 → albibong-1.1.0}/src/albibong/classes/item.py

@@ -1,9 +1,16 @@
 import json
 import os
 
-itemsJsonPath = os.path.join(os.path.dirname(__file__), "../resources/items.json")
-with open(itemsJsonPath) as json_file:
-    item_data = json.load(json_file)
+itemsByIdJsonPath = os.path.join(
+    os.path.dirname(__file__), "../resources/items_by_id.json"
+)
+itemsByUniqueNameJsonPath = os.path.join(
+    os.path.dirname(__file__), "../resources/items_by_unique_name.json"
+)
+with open(itemsByIdJsonPath) as json_file:
+    items_by_id = json.load(json_file)
+with open(itemsByUniqueNameJsonPath) as json_file:
+    items_by_unique_name = json.load(json_file)
 
 
 class Item:
@@ -17,6 +24,7 @@ class Item:
             if self.unique_name != "None"
             else "/No Equipment.png"
         )
+        self.quantity = 0
 
     @staticmethod
     def serialize(item):
@@ -25,6 +33,7 @@ class Item:
             "name": item.name,
             "unique_name": item.unique_name,
             "image": item.image,
+            "quantity": item.quantity,
         }
 
     @staticmethod
@@ -36,6 +45,12 @@ class Item:
 
     @classmethod
     def get_item_from_code(cls, code: str):
-        item = item_data[code]
+        item = items_by_id[code]
+
+        return cls(id=item["id"], name=item["name"], unique_name=item["unique_name"])
+
+    @classmethod
+    def get_item_from_unique_name(cls, unique_name: str):
+        item = items_by_unique_name[unique_name]
 
         return cls(id=item["id"], name=item["name"], unique_name=item["unique_name"])