albibong 1.0.7__py3-none-any.whl → 1.1.1__py3-none-any.whl

albibong/__init__.py

@@ -1,14 +1,22 @@
+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
@@ -17,6 +25,12 @@ 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()
@@ -25,12 +39,79 @@ def read_pcap(path):
         packet_handler.handle(packet)
 
 
-def sniff(useWebview):
+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)
-
+    p = SnifferThread(
+        name="sniffer", out_queue=packet_queue, sentinel=_sentinel, is_debug=is_debug
+    )
     c = PacketHandlerThread(
         name="packet_handler",
         in_queue=packet_queue,
@@ -44,7 +125,6 @@ def sniff(useWebview):
     ws_server.start()
 
     if useWebview:
-
         sock = socket.socket()
         sock.bind(("", 0))
         port = sock.getsockname()[1]
@@ -66,6 +146,7 @@ def sniff(useWebview):
             p.stop()
             ws_server.stop()
             http_server.stop()
+            db.close()
 
         window.events.closing += on_closing
 
@@ -81,9 +162,12 @@ def sniff(useWebview):
 
 def main(useWebview=True):
     if len(sys.argv) > 1:
-        ws_server = get_ws_server()
-        ws_server.start()
-
-        read_pcap(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/__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/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/classes/dungeon.py

@@ -1,59 +1,80 @@
-from datetime import datetime
 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:
+class Dungeon(BaseModel):
 
-    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
+    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_gained,
-            "silver": dungeon.silver_gained,
-            "re_spec": dungeon.re_spec_gained,
+            "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(dungeon.time_elapsed).split(".")[0],
+            "time_elapsed": (
+                str(time_elapsed).split(".")[0] if dungeon.end_time else ""
+            ),
+            "meter": dungeon.meter,
         }
 
-    @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 set_end_time(self):
+        self.end_time = datetime.now()
 
     def update_fame(self, parameters):
         fame = parameters[2] / DIVISOR
-        self.fame_gained += fame
+        self.fame += fame
 
     def update_re_spec(self, parameters):
         re_spec = parameters[2] / DIVISOR
-        self.re_spec_gained += re_spec
+        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_gained += silver
-        else:
-            self.loot.append(parameters[4])
+            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/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/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/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/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/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/classes/event_handler/handle_event_update_fame.py

@@ -1,7 +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/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/classes/event_handler/handle_operation_change_cluster.py

@@ -1,5 +1,5 @@
 from albibong.classes.event_handler.world_data_utils import WorldDataUtils
-from albibong.classes.location import Location
+from albibong.classes.location import Island, Location
 from albibong.classes.world_data import WorldData
 from albibong.threads.websocket_server import send_event
 
@@ -7,37 +7,32 @@ 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("_"))
+        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
+        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("_"))
+        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)
+    WorldDataUtils.ws_update_location(world_data)

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]
+            )