albibong 1.0.0__py3-none-any.whl

albibong/__init__.py

@@ -0,0 +1,82 @@
+import queue
+import sys
+from time import sleep
+
+import webview
+from scapy.all import rdpcap
+
+from albibong.classes.logger import Logger
+from albibong.classes.packet_handler import PacketHandler
+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)
+
+
+def read_pcap(path):
+    packet_handler = PacketHandler()
+    scapy_cap = rdpcap(path)
+    for packet in scapy_cap:
+        packet_handler.handle(packet)
+
+
+def sniff():
+    _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()
+
+    http_server = HttpServerThread(name="http_server")
+    http_server.start()
+
+    # sleep(0.25)
+    # with open("../gui/dist/index.html", "r") as html:
+    window = webview.create_window(
+        "Albibong",
+        # "../../gui/dist/index.html",
+        url="http://localhost:8000/",
+        width=1280,
+        height=720,
+        zoomable=True,
+    )
+
+    def on_closing():
+        c.stop()
+        p.stop()
+        ws_server.stop()
+        http_server.stop()
+
+    window.events.closing += on_closing
+
+    webview.start()
+
+
+def main():
+    if len(sys.argv) > 1:
+        ws_server = get_ws_server()
+        ws_server.start()
+
+        http_server = HttpServerThread(name="http_server")
+        http_server.start()
+
+        read_pcap(sys.argv[1])
+    else:
+        sniff()
+
+
+if __name__ == "__main__":
+    main()

albibong/classes/character.py

@@ -0,0 +1,83 @@
+import json
+
+from albibong.classes.coords import Coords
+from albibong.classes.item import Item
+from albibong.threads.websocket_server import send_event
+
+DIVISOR = 10000
+
+
+class Character:
+
+    def __init__(
+        self,
+        id: int,
+        username: str,
+        guild: str,
+        alliance: str,
+        coords: Coords,
+        equipment: list[Item] = [Item.get_item_from_code("0")] * 10,
+    ):
+        self.id = id
+        self.username = username
+        self.guild = guild
+        self.alliance = alliance
+        self.coords = coords
+        self.fame_gained: int = 0
+        self.re_spec_gained: int = 0
+        self.silver_gained: int = 0
+        self.damage_dealt: int = 0
+        self.healing_dealt: int = 0
+        self.loot: list[str] = []
+        self.equipment = equipment
+
+    def handle_health_update(self, parameters):
+        if 2 in parameters:
+            if parameters[2] < 0:
+                if parameters[0] != self.id:
+                    self.damage_dealt += abs(parameters[2])
+            else:
+                self.healing_dealt += abs(parameters[2])
+
+    def update_coords(self, parameters):
+        if 3 in parameters:
+            self.coords = Coords(parameters[3][0], parameters[3][1])
+
+    def update_fame(self, parameters):
+        fame = parameters[2] / DIVISOR
+        self.fame_gained += fame
+        event = {
+            "type": "update_fame",
+            "payload": {"username": self.username, "fame_gained": fame},
+        }
+        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": re_spec},
+        }
+        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": silver},
+                }
+                send_event(event)
+        else:
+            self.loot.append(parameters[4])
+
+    def update_equipment(self, equipments):
+        new_eq = []
+        if equipments != []:
+            for eq in equipments:
+                obj = Item.get_item_from_code(str(eq))
+                new_eq.append(obj)
+        self.equipment = new_eq

albibong/classes/coords.py

@@ -0,0 +1,9 @@
+class Coords:
+
+    def __init__(self, x, y):
+        self.x: float = x
+        self.y: float = y
+
+    @staticmethod
+    def serialize(coords):
+        return {"x": coords.x, "y": coords.y}

albibong/classes/dungeon.py

@@ -0,0 +1,59 @@
+from datetime import datetime
+import uuid
+
+DIVISOR = 10000
+
+
+class Dungeon:
+
+    def __init__(self, type, name) -> None:
+        self.id = uuid.uuid4()
+        self.type = type
+        self.name = name
+        self.tier = 0
+        self.fame_gained = 0
+        self.silver_gained = 0
+        self.re_spec_gained = 0
+        self.loot = []
+        self.start_time = datetime.now()
+        self.time_elapsed = 0
+
+    @staticmethod
+    def serialize(dungeon):
+        return {
+            "id": str(dungeon.id),
+            "type": dungeon.type,
+            "name": dungeon.name,
+            "tier": dungeon.tier,
+            "fame": dungeon.fame_gained,
+            "silver": dungeon.silver_gained,
+            "re_spec": dungeon.re_spec_gained,
+            "date_time": dungeon.start_time.strftime("%a %d %b %Y, %I:%M%p"),
+            "time_elapsed": str(dungeon.time_elapsed).split(".")[0],
+        }
+
+    @staticmethod
+    def serialize_many(dungeons):
+        serialized = []
+        for key, value in dungeons.items():
+            serialized.append(Dungeon.serialize(value))
+        return serialized
+
+    def get_elapsed_time(self):
+        end_time = datetime.now()
+        self.time_elapsed = end_time - self.start_time
+
+    def update_fame(self, parameters):
+        fame = parameters[2] / DIVISOR
+        self.fame_gained += fame
+
+    def update_re_spec(self, parameters):
+        re_spec = parameters[2] / DIVISOR
+        self.re_spec_gained += re_spec
+
+    def update_loot(self, parameters):
+        if 3 in parameters and parameters[3] == True:
+            silver = parameters[5] / DIVISOR
+            self.silver_gained += silver
+        else:
+            self.loot.append(parameters[4])

albibong/classes/item.py

@@ -0,0 +1,41 @@
+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)
+
+
+class Item:
+
+    def __init__(self, id: str, name: str, unique_name: str):
+        self.id = id
+        self.name = name
+        self.unique_name = unique_name
+        self.image = (
+            "https://render.albiononline.com/v1/item/" + self.unique_name
+            if self.unique_name != "None"
+            else "../public/No Equipment.png"
+        )
+
+    @staticmethod
+    def serialize(item):
+        return {
+            "id": item.id,
+            "name": item.name,
+            "unique_name": item.unique_name,
+            "image": item.image,
+        }
+
+    @staticmethod
+    def serialize_many(items):
+        serialized = []
+        for item in items:
+            serialized.append(Item.serialize(item))
+        return serialized
+
+    @classmethod
+    def get_item_from_code(cls, code: str):
+        item = item_data[code]
+
+        return cls(id=item["id"], name=item["name"], unique_name=item["unique_name"])

albibong/classes/location.py

@@ -0,0 +1,48 @@
+import json
+import os
+
+mapsJsonPath = os.path.join(os.path.dirname(__file__), "../resources/maps.json")
+with open(mapsJsonPath) as json_file:
+    map_data = json.load(json_file)
+
+
+class Location:
+
+    def __init__(self, id: str, name: str, type: str):
+        self.id = id
+        self.name = name
+        self.type = type
+
+    def is_black_zone(self):
+        if self.type == "OPENPVP_BLACK":
+            return True
+        elif self.type == "DUNGEON_BLACK":
+            return True
+        elif self.type == "PASSAGE_BLACK":
+            return True
+        elif self.type == "TUNNEL":
+            return True
+        else:
+            return False
+
+    def is_red_zone(self):
+        if self.type == "OPENPVP_RED":
+            return True
+        elif self.type == "DUNGEON_RED":
+            return True
+        elif self.type == "PASSAGE_RED":
+            return True
+        else:
+            return False
+
+    def is_safe_zone(self):
+        if self.is_black_zone() == False and self.is_red_zone() == False:
+            return True
+        else:
+            return False
+
+    @classmethod
+    def get_location_from_code(cls, code: str):
+        location = map_data[code]
+
+        return cls(id=location["id"], name=location["name"], type=location["type"])

albibong/classes/logger.py

@@ -0,0 +1,122 @@
+import json
+import logging
+import os
+from datetime import datetime, timezone
+
+from scapy.all import wrpcap
+
+from albibong.photon_packet_parser import EventData, OperationRequest, OperationResponse
+
+
+class Logger(logging.Logger):
+    def __init__(
+        self,
+        name,
+        stdout=False,
+        log_to_file=True,
+        ignore_event=False,
+        ignore_request=False,
+        ignore_response=False,
+    ):
+        super().__init__(name)
+        self.ignore_event = ignore_event
+        self.ignore_request = ignore_request
+        self.ignore_response = ignore_response
+
+        self.file_timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H%M%S")
+        log_filepath = os.path.join(
+            os.path.expanduser("~"), f"Albibong/log/log_{self.file_timestamp}.txt"
+        )
+        os.makedirs(os.path.dirname(log_filepath), exist_ok=True)
+
+        self.setLevel(logging.DEBUG)
+        log_formatter = logging.Formatter("%(message)s")
+
+        if log_to_file:
+            file_handler = logging.FileHandler(log_filepath)
+            file_handler.setFormatter(log_formatter)
+            file_handler.setLevel(logging.INFO)
+            self.addHandler(file_handler)
+
+        if stdout:
+            stdout_handler = logging.StreamHandler()
+            stdout_handler.setFormatter(log_formatter)
+            stdout_handler.setLevel(logging.INFO)
+            self.addHandler(stdout_handler)
+
+        # Load Event and Operation Code for logging
+        eventCodeJsonPath = os.path.join(
+            os.path.dirname(__file__), "../resources/event_code.json"
+        )
+        with open(eventCodeJsonPath) as json_file:
+            data = json.load(json_file)
+            self.event_code = data
+
+        operationCodeJsonPath = os.path.join(
+            os.path.dirname(__file__), "../resources/operation_code.json"
+        )
+        with open(operationCodeJsonPath) as json_file:
+            data = json.load(json_file)
+            self.operation_code = data
+
+    def get_timestamp(self):
+        return datetime.now(timezone.utc).strftime("%H:%M:%S")
+
+    def log_payload(self, payload):
+        if type(payload) == EventData:
+            self.log_event(payload)
+        elif type(payload) == OperationRequest:
+            self.log_request(payload)
+        elif type(payload) == OperationResponse:
+            self.log_response(payload)
+
+    def log_dps_meter_state(self, state: bool):
+        text = f"{self.get_timestamp()} DPS METER IS {'RUNNING. The damages below this point will be recorded.' if state else 'PAUSED. The damages below this point will NOT be recorded.'}"
+        self.info(text)
+        print(text)
+
+    def log_event(self, payload: EventData):
+        if self.ignore_event:
+            return
+
+        # Ignore position update, timesync, and guild updates
+        if payload.code == 3:
+            return
+
+        parameters = payload.parameters
+        if 252 in parameters and parameters[252] in {99, 100, 152}:
+            return
+
+        event_code = str(parameters[252]) if 252 in parameters else None
+        if event_code in self.event_code:
+            event_code = self.event_code[event_code]
+
+        self.info(f"{self.get_timestamp()} event {event_code}")
+        self.info(parameters)
+
+    def log_request(self, payload: OperationRequest):
+        if self.ignore_request:
+            return
+
+        parameters = payload.parameters
+        operation_code = str(parameters[253]) if 253 in parameters else None
+        if operation_code in self.operation_code:
+            operation_code = self.operation_code[operation_code]
+
+        self.info(f"{self.get_timestamp()} request {operation_code}")
+        self.info(parameters)
+
+    def log_response(self, payload: OperationResponse):
+        if self.ignore_response:
+            return
+
+        parameters = payload.parameters
+        operation_code = str(parameters[253]) if 253 in parameters else None
+        if operation_code in self.operation_code:
+            operation_code = self.operation_code[operation_code]
+
+        self.info(f"{self.get_timestamp()} response {operation_code}")
+        self.info(parameters)
+
+    def log_error_pcap(self, packet):
+        wrpcap(f"../pcap/error_{self.file_timestamp}.pcapng", packet, append=True)

albibong/classes/packet_handler.py

@@ -0,0 +1,61 @@
+import functools
+import traceback
+
+from scapy.all import UDP, Packet
+
+from albibong.classes.logger import Logger
+from albibong.classes.world_data import WorldData, get_world_data
+from albibong.photon_packet_parser import (
+    EventData,
+    OperationRequest,
+    OperationResponse,
+    PhotonPacketParser,
+)
+
+logger = Logger(__name__, ignore_request=True)
+
+
+def log_payload(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            payload = func(*args, **kwargs)
+            logger.log_payload(payload)
+        except:
+            print(f"ERROR {func.__name__}: {traceback.format_exc()}")
+
+    return wrapper
+
+
+class PacketHandler:
+    def __init__(self):
+        self.parser = PhotonPacketParser(
+            self.on_event, self.on_request, self.on_response
+        )
+        self.world_data = get_world_data()
+
+    @log_payload
+    def on_event(self, payload: EventData):
+        self.world_data.handle_event(payload.parameters)
+        return payload
+
+    @log_payload
+    def on_request(self, payload: OperationRequest):
+        self.world_data.handle_request(payload.parameters)
+        return payload
+
+    @log_payload
+    def on_response(self, payload: OperationResponse):
+        self.world_data.handle_response(payload.parameters)
+        return payload
+
+    def handle(self, packet: Packet):
+        try:
+            payload = packet[UDP].payload.original
+            self.parser.handle_payload(payload)
+        except Exception as e:
+            if type(e) == KeyboardInterrupt:
+                raise e
+
+            print(f"ERROR HANDLE: {traceback.format_exc()}")
+            logger.log_error_pcap(packet)