albibong 1.0.6__py3-none-any.whl → 1.1.0__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 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
@@ -17,6 +25,10 @@ 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()
@@ -43,6 +55,51 @@ def sniff(useWebview):
     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()
@@ -66,6 +123,7 @@ def sniff(useWebview):
             p.stop()
             ws_server.stop()
             http_server.stop()
+            db.close()
 
         window.events.closing += on_closing
 

albibong/classes/dungeon.py

@@ -1,22 +1,26 @@
-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 = 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):
@@ -25,35 +29,38 @@ class Dungeon:
             "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,
+            "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.time_elapsed).split(".")[0],
+            "time_elapsed": (
+                str(dungeon.end_time - dungeon.start_time).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_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

@@ -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/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_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_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]
+            )

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/classes/event_handler/world_data_utils.py

@@ -1,38 +1,65 @@
-from collections import deque
 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 Location
+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
 
-FILENAME = os.path.join(os.path.expanduser("~"), "Albibong/list_dungeon.json")
-os.makedirs(os.path.dirname(FILENAME), exist_ok=True)
+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 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)
+    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)
 
-            WorldDataUtils.ws_update_dungeon(list(list_dungeon))
+    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):
@@ -45,17 +72,27 @@ class WorldDataUtils:
     @staticmethod
     def start_current_dungeon(world_data: WorldData, type: str, name: str):
         if world_data.current_dungeon == None:
-            new_dungeon = Dungeon(type, name)
+            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 "DUNGEON" in map_type_splitted:
+        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
         ):
@@ -92,11 +129,27 @@ class WorldDataUtils:
         else:
             char.update_heal_dealt(nominal)
 
-        WorldDataUtils.ws_update_damage_heal(world_data)
+        WorldDataUtils.ws_update_damage_meter(world_data)
 
-    def ws_update_damage_heal(world_data: WorldData):
+    def ws_update_damage_meter(world_data: WorldData):
         event = {
-            "type": "update_dps",
+            "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/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"])