Npc optimization

commands/asy.py

@@ -0,0 +1,14 @@
+from typing import TYPE_CHECKING
+from response import ExtensionResponse
+
+if TYPE_CHECKING:
+    from server import CafeServer
+    from asyncio import StreamWriter
+
+
+async def handle_asy(server: 'CafeServer', client: 'StreamWriter') -> None:
+    address = client.get_extra_info('peername')
+    player = server.clients[address]
+
+    response = ExtensionResponse('asy', '-1', '0', str(player.cash), str(player.gold))
+    await server.send_response(client, response)

commands/ebu.py

@@ -70,14 +70,15 @@ async def handle_ebu(server: 'CafeServer', client: 'StreamWriter', *params: str)
         new_object.pos = [int(pos_x), int(pos_y)]
         new_object.rotation = int(rotation)
 
-        player.cafe.objects.append(new_object)
-
         if int(obj_id) in DOOR_IDs:
             for obj in player.cafe.objects:
                 if obj.id in DOOR_IDs:
                     player.cafe.furniture_inventory[obj.id] = 1
                     player.cafe.objects.remove(obj)
 
+        player.cafe.objects.append(new_object)
+
+        if int(obj_id) in DOOR_IDs:
             player.cafe.player_start = player.cafe.get_start_pos()
 
     server.db.update_cafe(player.id,

commands/edi.py

@@ -1,9 +1,11 @@
 from typing import TYPE_CHECKING
+
+from commands.asy import handle_asy
+from objects.cafe_object import ObjectType
+from objects.customer import spawn_cycle
+from objects.waiter import spawn_waiters
 from response import ExtensionResponse
 from asyncio import create_task
-from objects.waiter import spawn_multiple
-from objects.customer import spawn_cycle
-from objects.cafe_object import ObjectType
 
 if TYPE_CHECKING:
     from server import CafeServer
@@ -18,25 +20,51 @@ async def handle_edi(server: 'CafeServer', client: 'StreamWriter', *params: str)
 
     match int(params[1]):
         case 0:
-            create_task(spawn_multiple(server, player.cafe))
-            player.customer_cycle = create_task(spawn_cycle(server, player.cafe))
             player.cafe.connect_chairs()
 
+            create_task(spawn_waiters(server, client))
+
+            print(f'Created a new customer cycle\nUsed this player\'s Cafe: {player.avatar.username}')
+            player.cafe.customer_cycle = create_task(spawn_cycle(server, client))
+
         case 1:
+            vending_machine = None
+            for obj in player.cafe.objects:
+                if obj.type == ObjectType.VENDING:
+                    vending_machine = obj
+
             for waiter in player.cafe.waiters:
                 if waiter.task:
                     waiter.task.cancel()
 
-            if player.customer_cycle:
-                player.customer_cycle.cancel()
+            if player.cafe.customer_cycle:
+                player.cafe.customer_cycle.cancel()
                 player.customer_cycle = None
 
             for customer in player.cafe.customers:
                 if customer.task:
                     customer.task.cancel()
 
+                # TO UPDATE THE VENDING MACHINE AMOUNT IN VISUAL TOO!
+                # THE ASY NEED TO SYNC THE MONEY!
+                # THE XP IS NOT SYNCED WITH THE CLIENT :(
+
+                if customer.action == 9:
+                    await customer._use_vending_machine(server, player, vending_machine)
+
+            if vending_machine and vending_machine.fast_food_amount < 1:
+                vending_machine.fast_food_id = -1
+                server.db.update_cafe(player.id, objects=player.cafe.get_objects_as_json())
+
+            await handle_asy(server, client)
+
+            player.cafe.customers = []
+
             for table in player.cafe.available_tables:
                 table.busy = False
+                chair = table.connected_chair
+                chair.dish_id = -1
+                chair.dish_status = 0
 
     response = ExtensionResponse('edi', '-1', '0', params[1], str(pos[0]), str(pos[1]), '')
     await server.send_response(client, response)

commands/ffc.py

@@ -0,0 +1,51 @@
+from typing import TYPE_CHECKING
+from response import ExtensionResponse
+from utils.items import get_fast_food_info
+if TYPE_CHECKING:
+    from server import CafeServer
+    from asyncio import StreamWriter
+
+
+async def handle_ffc(server: 'CafeServer', client: 'StreamWriter', *params: str) -> None:
+    address = client.get_extra_info('peername')
+    player = server.clients[address]
+
+    pos_x = int(params[1])
+    pos_y = int(params[2])
+    drink_id = int(params[3])
+
+    drink = get_fast_food_info(drink_id)
+    if not drink:
+        return
+
+    cost_cash = drink['cash']
+    cost_gold = drink['gold']
+    amount = drink['amount']
+
+    if not cost_cash == 0:
+        if player.cash < cost_cash:
+            response = ExtensionResponse('ffc', '-1', '4')
+            await server.send_response(client, response)
+            return
+        else:
+            player.cash -= cost_cash
+            server.db.update_player(player.id, cash=player.cash)
+
+    if not cost_gold == 0:
+        if player.gold < cost_gold:
+            response = ExtensionResponse('ffc', '-1', '4')
+            await server.send_response(client, response)
+            return
+        else:
+            player.gold -= cost_gold
+            server.db.update_player(player.id, gold=player.gold)
+
+    obj = player.cafe.get_object(pos_x, pos_y)
+    obj.fast_food_id = drink_id
+    obj.fast_food_amount = amount
+
+    server.db.update_cafe(player.id, objects=player.cafe.get_objects_as_json())
+
+    for user in player.cafe.clients:
+        response = ExtensionResponse('ffc', '-1', '0', params[1], params[2], str(drink_id))
+        await server.send_response(user, response)

commands/ffn.py

@@ -0,0 +1,75 @@
+from math import ceil
+from typing import TYPE_CHECKING
+
+from objects.cafe import get_time
+from response import ExtensionResponse
+
+from utils.items import get_fast_food_info
+
+if TYPE_CHECKING:
+    from server import CafeServer
+    from asyncio import StreamWriter
+
+
+class ErrorCodes:
+    noFrosty_goShop = '999'
+    allServed = '103'
+    notReachable = '36'
+
+
+async def handle_ffn(server: 'CafeServer', client: 'StreamWriter', *params: str) -> None:
+    address = client.get_extra_info('peername')
+    player = server.clients[address]
+
+    customer_id = int(params[1])
+    obj_pos_x = int(params[2])
+    obj_pos_y = int(params[3])
+
+    obj = player.cafe.get_object(obj_pos_x, obj_pos_y)
+
+    if not obj:
+        # not really need, the game sends before the server, but we should keep it
+        response = ExtensionResponse('ffn', '-1', ErrorCodes.noFrosty_goShop)
+        await server.send_response(client, response)
+        return
+
+    if not obj.fast_food_amount > 0:
+        response = ExtensionResponse('ffn', '-1', ErrorCodes.allServed)
+        await server.send_response(client, response)
+        return
+
+    facing_pos = [0, 0]
+
+    nearby_pos = obj.get_nearby_pos()
+    for pos, rotation in nearby_pos.items():
+        if rotation == obj.rotation:
+            facing_pos = pos
+
+    if get_time(player.cafe, facing_pos) == -1:
+        response = ExtensionResponse('ffn', '-1', ErrorCodes.notReachable)
+        await server.send_response(client, response)
+        return
+
+    for customer in player.cafe.customers:
+        if customer.id == customer_id:
+            customer.action = 9
+            break
+
+    fast_food_info = get_fast_food_info(obj.fast_food_id)
+    income = fast_food_info.get('income')
+    xp = fast_food_info.get('xp')
+    rating = fast_food_info.get('rating')
+
+    player.cafe.update_rating(rating)
+
+    player.cash += income
+    player.xp += ceil(xp * (player.get_level() + 18) / 190)
+
+    obj.fast_food_amount -= 1
+
+    server.db.update_player(player.id, cash=player.cash, xp=player.xp)
+
+    server.db.update_cafe(player.id, rating=player.cafe.rating, objects=player.cafe.get_objects_as_json())
+
+    response = ExtensionResponse('ffn', '-1', '0', str(customer_id), str(obj_pos_x), str(obj_pos_y))
+    await server.send_response(client, response)

commands/jca.py

@@ -1,12 +1,13 @@
 from typing import TYPE_CHECKING
+
+from commands.asy import handle_asy
+from objects.waiter import spawn_waiters, spawn_waiters_to_client
 from response import ExtensionResponse
 from commands.sgc import handle_sgc
 from commands.ifr import handle_ifr
 from commands.ein import handle_ein
-from objects.waiter import spawn_multiple
-from objects.customer import spawn_cycle, Action
-from objects.cafe_object import CafeObject, ObjectType
 from asyncio import create_task
+from objects.customer import spawn_cycle, spawn_customers_to_client
 
 if TYPE_CHECKING:
     from server import CafeServer
@@ -15,6 +16,8 @@
 
 async def handle_jca(server: 'CafeServer', client: 'StreamWriter', *params: str) -> None:
     wanted_player_id = int(params[2])
+    address = client.get_extra_info('peername')
+    player = server.clients[address]
 
     check_player = [player for player in server.players if player.id == wanted_player_id]
     if check_player:
@@ -31,51 +34,14 @@ async def handle_jca(server: 'CafeServer', client: 'StreamWriter', *params: str)
     await handle_ifr(server, client, *params)
     await handle_ein(server, client, *params)
 
-    create_task(spawn_multiple(server, wanted_player.cafe))
-
-    # TODO: Broken for other player's cafe
-    # Tries to use player's cafe objects instead of the other player's
-    if not wanted_player.customer_cycle:
-        print(f'created waiter cycle\nused this player\'s cafe: f{wanted_player.avatar.username}')
-        # TODO: add random customers
-        wanted_player.customer_cycle = create_task(spawn_cycle(server, wanted_player.cafe))
-    else:
-        customers = wanted_player.cafe.customers
-
-        print(f'customers: {customers}')
-
-        for customer in customers:
-            spawn_info = '+'.join(map(str, [
-                customer.id,                     # Customer ID
-                0,                               # NPC type (0: Customer)
-                0,                               # Favourite dish
-                -1,                              # Dish ID
-                0,                               # Is thirsty
-                customer.avatar.to_string(True)  # Avatar
-            ]))
-
-            response_spawn = ExtensionResponse('nav', '-1', '0', spawn_info)
+    if wanted_player.id == player.id:
+        await handle_asy(server, client)
 
-            location = wanted_player.cafe.get_object(*customer.pos)
-
-            if isinstance(location, CafeObject) and location.type == ObjectType.CHAIR:
-                sit_down_info = '+'.join(map(str, [
-                    customer.id,          # Customer ID
-                    Action.SIT_DOWN,  # Action type (2: Sit down)
-                    customer.pos[0],     # X
-                    customer.pos[1]      # Y
-                ]))
-
-                response = ExtensionResponse('nac', '-1', '0', sit_down_info)
-
-            else:
-                insert_info = '+'.join(map(str, [
-                    str(customer.id),  # Customer ID
-                    Action.INSERT  # Action type (0: Insert)
-                ]))
-
-                response = ExtensionResponse('nac', '-1', '0', insert_info)
-
-            await server.send_response(client, response_spawn)
-            await server.send_response(client, response)
+    if not wanted_player.cafe.customer_cycle:
+        print(f'Created a new customer cycle\nUsed this player\'s Cafe: {wanted_player.avatar.username}')
+        wanted_player.cafe.customer_cycle = create_task(spawn_cycle(server, wanted_player.client))
 
+        create_task(spawn_waiters(server, wanted_player.client))
+    else:
+        create_task(spawn_customers_to_client(server, client, wanted_player.cafe))
+        create_task(spawn_waiters_to_client(server, client, wanted_player.cafe))