[+] Improved Inventory System based on old Inventory Manager and new GUI. (test version)

ReallifeGamemode.Server/Managers/InventoryManager.cs

@@ -6,7 +6,9 @@ using ReallifeGamemode.Server.Inventory;
 using ReallifeGamemode.Server.Inventory.Interfaces;
 using ReallifeGamemode.Server.Models;
 using ReallifeGamemode.Server.Services;
+using ReallifeGamemode.Server.Util;
 using System;
+using System.Timers;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
@@ -23,6 +25,11 @@ namespace ReallifeGamemode.Server.Managers
   {
     public static List<IItem> itemList;
 
+    private static Dictionary<int, (int[], int[])> TradeItems { get; set; } = new Dictionary<int, (int[], int[])>();
+    private static Dictionary<int, Timer> TradeTimer { get; set; } = new Dictionary<int, Timer>();
+    private static Dictionary<int, int> TradeValue { get; set; } = new Dictionary<int, int>();
+
+
     public static void LoadItems()
     {
       itemList = new List<IItem>();
@@ -77,26 +84,36 @@ namespace ReallifeGamemode.Server.Managers
     {
       var user = player.GetUser();
       var inventoryWeight = 0;
+      List<string> iName = new List<string>();
+      List<int> iAmount = new List<int>();
+      List<int> iId = new List<int>();
+      List<int> iWeight = new List<int>();
 
       using (var context = new DatabaseContext())
       {
         List<UserItem> userItems = context.UserItems.ToList().FindAll(i => i.UserId == user.Id);
-        string[][] items = new string[userItems.Count][];
+
+
         foreach (var item in userItems)
         {
           IItem iItem = GetItemById(item.ItemId);
           var currentItemWeight = iItem.Gewicht * item.Amount;
           inventoryWeight += currentItemWeight;
 
-          items[userItems.IndexOf(item)] = new string[6];
-          items[userItems.IndexOf(item)][0] = iItem.Name;
-          items[userItems.IndexOf(item)][1] = iItem.Description;
-          items[userItems.IndexOf(item)][2] = iItem.Gewicht.ToString();
-          items[userItems.IndexOf(item)][3] = item.Amount.ToString();
-          items[userItems.IndexOf(item)][4] = item.Slot.ToString();
-          items[userItems.IndexOf(item)][5] = item.Id.ToString();
+          iName.Add(iItem.Name);
+          iAmount.Add(item.Amount);
+          iId.Add(iItem.Id);
+
         }
-        player.TriggerEvent("showInventory", inventoryWeight, items);
+        List<Client> targetList = NAPI.Player.GetPlayersInRadiusOfPlayer(2, player);
+        List<string> username = new List<string>();
+        foreach (var target in targetList)
+        {
+          User cl = target.GetUser();
+          username.Add(cl.Name);
+        }
+
+        player.TriggerEvent("inventoryShow", inventoryWeight, iName.ToArray(), iAmount.ToArray(), iId.ToArray(), username.ToArray());
       }
     }
 
@@ -155,43 +172,199 @@ namespace ReallifeGamemode.Server.Managers
       }
     }
 
-    [RemoteEvent("saveInventory")]
-    public void SavePlayerInventory(Client player, string itemArray)
+    public bool CheckOriginOfItem(Client client, string jsonItemID, string jsonItemAmount, string jsonOrigin, string jsonVehAmount)
     {
+      var origin = JsonConvert.DeserializeObject<int[]>(jsonOrigin);
+      var itemID = JsonConvert.DeserializeObject<int>(jsonItemID);
+      var itemAmount = JsonConvert.DeserializeObject<int>(jsonItemAmount);
+      var vehAmount = JsonConvert.DeserializeObject<int>(jsonVehAmount);
+      var user = client.GetUser();
+      using (var context = new DatabaseContext())
+      {
+        if (origin[0] == 1)
+        {
+          foreach (Vehicle veh in NAPI.Pools.GetAllVehicles())
+          {
+            if (veh.Position.DistanceTo(client.Position) < 2)
+            {
+              if (VehicleStreaming.GetDoorState(veh, DoorID.DoorTrunk) == DoorState.DoorOpen)
+              {
 
-      var user = player.GetUser();
-      var items = JsonConvert.DeserializeObject<string[][]>(itemArray);
+                UserItem vItem = new UserItem
+                {
+                  Amount = vehAmount,
+                  ItemId = itemID,
+                  UserId = user.Id,
+                  Slot = -1
+                };
+
+                ServerVehicle serverVehicle = VehicleManager.GetServerVehicleFromVehicle(veh, context);
+                VehicleItem vehItem = context.VehicleItems.Where(v => v.VehicleId == origin[1] && v.ItemId == vItem.ItemId).FirstOrDefault();
+                if (vehItem != null)
+                {
+                  if (itemAmount < vehItem.Amount)
+                  {
+                    UserItem uItem = context.UserItems.Where(u => u.UserId == user.Id && u.ItemId == vItem.ItemId).FirstOrDefault();
+                    if (uItem == null)
+                    {
+                      context.Add(vItem);
+                    }
+                    else
+                    {
+                      uItem.Amount += vItem.Amount;
+                    }
+                    context.SaveChanges();
+                    return true;
+                  }
+                  else if (itemAmount == vehItem.Amount)
+                  {
+                    UserItem uItem = context.UserItems.Where(u => u.UserId == user.Id && u.ItemId == vItem.ItemId).FirstOrDefault();
+                    if (uItem == null)
+                    {
+                      context.Add(vItem);
+                    }
+                    else
+                    {
+                      uItem.Amount += vItem.Amount;
+                    }
+                    context.SaveChanges();
+                    return true;
+                  }
+                  return false;
+                }
+              }
+            }
+          }
+        }
+        else if (origin[0] == 0)
+        {
+          
+          VehicleItem cItem = new VehicleItem
+          {
+            Amount = vehAmount,
+            ItemId = itemID,
+            VehicleId = origin[1],
+            Slot = -1,
+          };
+
+          UserItem uItem = context.UserItems.Where(u => u.UserId == user.Id && u.ItemId == cItem.ItemId).FirstOrDefault();
+          if (uItem != null)
+          {
+            if (vehAmount < uItem.Amount)
+            {
+
+              VehicleItem vehItem = context.VehicleItems.Where(v => v.VehicleId == cItem.VehicleId && v.ItemId == cItem.ItemId).FirstOrDefault();
+              if (vehItem == null)
+              {
+                context.Add(cItem);
+              }
+              else
+              {
+                vehItem.Amount += cItem.Amount;
+              }
+              context.SaveChanges();
+              return true;
+
+
+            }
+            else if (vehAmount == uItem.Amount)
+            {
+              VehicleItem vehItem = context.VehicleItems.Where(v => v.VehicleId == cItem.VehicleId && v.ItemId == cItem.ItemId).FirstOrDefault();
+              if (vehItem == null)
+              {
+                context.Add(cItem);
+              }
+              else
+              {
+                vehItem.Amount += cItem.Amount;
+              }
+              context.SaveChanges();
+              return true;
+            }
+            return false;
+          }
+        }
+        return false;
+      }
+    }
+
+    [RemoteEvent("saveVehicleInventory")]
+    public void SaveVehicleInventory(Client player, string jsonItemID, string jsonItemAmount, string jsonGotFrom, string vehAmount)
+    {
+      var itemID = JsonConvert.DeserializeObject<int>(jsonItemID);
+      var itemAmount = JsonConvert.DeserializeObject<int>(jsonItemAmount);
+      var origin = JsonConvert.DeserializeObject<int[]>(jsonGotFrom);
+
+      if (!CheckOriginOfItem(player, jsonItemID, jsonItemAmount, jsonGotFrom, vehAmount))
+        return;
 
       using (var context = new DatabaseContext())
       {
-        for (var i = 0; i < items.Length; i++)
+
+
+        VehicleItem vItem = new VehicleItem
         {
+          Amount = itemAmount,
+          ItemId = itemID,
+          VehicleId = origin[1],
+          Slot = -1
+        };
+
+        VehicleItem vehItem = context.VehicleItems.Where(v => v.VehicleId == vItem.VehicleId && v.ItemId == vItem.ItemId).FirstOrDefault();
+        if (vehItem == null)
+        {
+          context.VehicleItems.Add(vItem);
+        }
+        else if (vItem.Amount <= 0)
+        {
+          context.VehicleItems.Remove(vehItem);
+        }
+        else
+        {
+          vehItem.Amount = vItem.Amount;
+        }
+        context.SaveChanges();
+
+      }
+    }
+
+
+    [RemoteEvent("saveInventory")]
+    public void SavePlayerInventory(Client player, string jsonItemID,string jsonItemAmount, string jsonGotFrom, string vehAmount)
+    {
+
+      var user = player.GetUser();
+      var itemID = JsonConvert.DeserializeObject<int>(jsonItemID);
+      var itemAmount = JsonConvert.DeserializeObject<int>(jsonItemAmount);
+
+      if (!CheckOriginOfItem(player,jsonItemID, jsonItemAmount,jsonGotFrom, vehAmount))
+        return;
+
+      using (var context = new DatabaseContext())
+      {
+
           UserItem cItem = new UserItem
           {
-            Amount = int.Parse(items[i][3]),
-            ItemId = GetItemByName(items[i][0]).Id,
+            Amount = itemAmount,
+            ItemId = itemID,
             UserId = user.Id,
-            Slot = int.Parse(items[i][4]),
+            Slot = -1,
           };
-
-          if (int.Parse(items[i][5]) == -1)
+          UserItem item = context.UserItems.Where(u => u.UserId == user.Id && u.ItemId == cItem.ItemId).FirstOrDefault();
+          if (item == null)
           {
             context.UserItems.Add(cItem);
           }
-          else if (cItem.Slot == -1)
-          {
-            UserItem fItem = context.UserItems.FirstOrDefault(j => j.Id == int.Parse(items[i][5]));
-            context.UserItems.Remove(fItem);
+          else if (cItem.Amount <= 0)
+          {           
+            context.UserItems.Remove(item);
           }
           else
           {
-            UserItem fItem = context.UserItems.FirstOrDefault(j => j.Id == int.Parse(items[i][5]));
-            fItem.Amount = cItem.Amount;
-            fItem.Slot = cItem.Slot;
+            item.Amount = cItem.Amount;
           }
-        }
+
         context.SaveChanges();
-        player.TriggerEvent("SERVER:INVENTORY_SYNC");
       }
     }
 
@@ -230,7 +403,7 @@ namespace ReallifeGamemode.Server.Managers
     }
 
     [RemoteEvent("removeItemAsAdmin")]
-    public void SavePlayerInventory(Client player, string amount, string userItemId, string targetPlayerName)
+    public void RemoveAsAdminInventory(Client player, string amount, string userItemId, string targetPlayerName)
     {
       using (var context = new DatabaseContext())
       {
@@ -253,12 +426,20 @@ namespace ReallifeGamemode.Server.Managers
         context.SaveChanges();
       }
     }
+
+
     [RemoteEvent("itemInteract")]
-    public void ItemInteract(Client player, string type, string itemId, int amount)
+    public void ItemInteract(Client player, string jsonType, string jsonItemId, string jsonAmount)
     {
+      int amount = JsonConvert.DeserializeObject<int>(jsonAmount);
+      int itemId = JsonConvert.DeserializeObject<int>(jsonItemId);
+      string type = JsonConvert.DeserializeObject<string>(jsonType);
+
+      User user = player.GetUser();
+
       using (var context = new DatabaseContext())
       {
-        UserItem fItem = context.UserItems.FirstOrDefault(j => j.Id == int.Parse(itemId));
+        UserItem fItem = context.UserItems.Where(u => u.UserId == user.Id && u.ItemId == itemId).FirstOrDefault();
         IItem iItem = GetItemById(fItem.ItemId);
 
         switch (type)
@@ -282,7 +463,7 @@ namespace ReallifeGamemode.Server.Managers
               usableItemObj.Use(fItem);
               player.TriggerEvent("removeItem", itemId, amount);
             }
-            else ChatService.SendMessage(player, "not useable");
+            else ChatService.SendMessage(player, "Du kannst dieses Item nicht benutzen.");
             break;
           case "drop":
 
@@ -308,13 +489,246 @@ namespace ReallifeGamemode.Server.Managers
               GroundItem grndItem = new GroundItem { ItemId = iItem.Id, Amount = amount, Position = dropPosition };
               TextLabel grndTxtLbl = NAPI.TextLabel.CreateTextLabel(iItem.Name + " ~s~(~y~" + amount + "~s~)", dropPosition, 5, 0.5f, 4, new Color(255, 255, 255), false, 0);
               GroundItem.AddGroundItem(grndItem, grndObject, grndTxtLbl);
-              fItem.Amount -= amount;
-              player.TriggerEvent("removeItem", itemId, amount);
+              if(fItem.Amount > amount)
+              {
+                fItem.Amount -= amount;
+              }else if(fItem.Amount == amount)
+              {
+                context.UserItems.Remove(fItem);
+              }
+              
             }
             break;
         }
         context.SaveChanges();
       }
     }
+
+
+    [RemoteEvent("tradeItem")]
+    public void ServerEvent_tradeItem(Client client, int value, string nameOrId, string itemIdArrStr, string itemAmountArrStr)
+    {
+      User user = client.GetUser();
+      Client target = ClientService.GetClientByNameOrId(nameOrId);
+      if (target == null || !target.IsLoggedIn() || target == client)
+      {
+        ChatService.PlayerNotFound(client);
+        return;
+      }
+      if (client.Position.DistanceTo(target.Position) >= 5)
+      {
+        ChatService.ErrorMessage(client, "Spieler ist zu weit entfernt.");
+        return;
+      }
+      int[] itemIdArr = JsonConvert.DeserializeObject<int[]>(itemIdArrStr);
+      int[] itemAmountArr = JsonConvert.DeserializeObject<int[]>(itemAmountArrStr);
+      List<string> itemNameList = new List<string>();
+      
+
+      if (target.HasData("inTrade") && target.GetData("inTrade") == true)
+      {
+        ChatService.SendMessage(client, $"~r~[FEHLER] ~w~{target.Name} befindet sich bereits in einem Handel.");
+        return;
+      }
+      int inventoryWeight = 0;
+      using (var context = new DatabaseContext())
+      {
+        int targetInvWeight = GetUserInventoryWeight(target);
+        
+        for (int i = 0; i < itemIdArr.Length; i++)
+        {
+          int itemId = itemIdArr[i];
+          int itemAmount = itemAmountArr[i];
+          UserItem uitem = context.UserItems.Where(u => u.UserId == user.Id && u.ItemId == itemId).FirstOrDefault();
+          IItem iItem = GetItemById(uitem.ItemId);
+          var currentItemWeight = iItem.Gewicht * itemAmount;
+          inventoryWeight += currentItemWeight;
+        }
+        if (((targetInvWeight + inventoryWeight) / 1000) > 40)
+        {
+          ChatService.ErrorMessage(client, "Handel kann nicht getätigt werden.");
+          return;
+        }
+
+        for (int x = 0; x < itemIdArr.Length; x++)
+        {
+          int itemId = itemIdArr[x];
+          int itemAmount = itemAmountArr[x];
+          UserItem item = context.UserItems.Where(u => u.UserId == user.Id && u.ItemId == itemId).FirstOrDefault();
+          if (item.Amount - itemAmount > 0)
+          {
+            item.Amount -= itemAmount;
+          }
+          else
+          {
+            context.UserItems.Remove(item);
+          }
+          IItem iItem = GetItemById(itemId);
+          itemNameList.Add(iItem.Name);
+          context.SaveChanges();
+        }
+      }
+      ChatService.SendMessage(client, $"~b~Du hast eine Handelsanfrage an {target.Name} gesendet.");
+      TradeItems[user.Id] = (itemIdArr, itemAmountArr);
+      TradeValue[user.Id] = value;
+      target.SetData("tradePartner", user.Id);
+      target.SetData("trade", client.Name);
+      SendTradeOffer(target, client);
+      target.TriggerEvent("addTradeItems", itemIdArr, itemAmountArr, itemNameList.ToArray(), inventoryWeight);
+    }
+
+    public void SendTradeOffer(Client client, Client sender)
+    {
+      client.SetData("inTrade", true);
+      sender.SetData("inTrade", true);
+      ChatService.SendMessage(client, $"~b~ Du hast eine Handelsanfrage von {sender.Name} bekommen.");
+      client.SetSharedData("tradeOffer", 1);
+      User user = sender.GetUser();
+      Timer tradeTimer = new Timer(30000);
+      TradeTimer[user.Id] = tradeTimer;
+      tradeTimer.Start();
+      tradeTimer.Elapsed += (s, e) => { SendBackToSender(sender); client.SetData("inTrade", false); sender.SetData("inTrade", false); client.SetSharedData("tradeOffer", 0); };
+    }
+
+    public void SendBackToSender(Client client)
+    {
+      User user = client.GetUser();
+      ChatService.SendMessage(client, "Dein Handelspartner hat die Anfrage nicht angenommen.");
+      (int[] itemIdArr, int[] itemAmountArr) = TradeItems[user.Id];
+      Timer timer = TradeTimer[user.Id];
+      timer.Stop();
+      using (var context = new DatabaseContext())
+      {
+        for (int x = 0; x < itemIdArr.Length; x++)
+        {
+          int itemId = itemIdArr[x];
+          int itemAmount = itemAmountArr[x];
+          UserItem item = context.UserItems.Where(u => u.UserId == user.Id && u.ItemId == itemId).FirstOrDefault();
+          if (item != null)
+          {
+            item.Amount += itemAmount;
+          }
+          else
+          {
+            var newItem = new UserItem
+            {
+              ItemId = itemId,
+              UserId = user.Id,
+              Amount = itemAmount,
+              Slot = -1
+            };
+
+            context.UserItems.Add(newItem);
+          }
+          context.SaveChanges();
+        }
+      }
+    }
+
+    [RemoteEvent("declineTrade")]
+    public void ServerEvent_declineTrade(Client client)
+    {
+      client.SetSharedData("tradeOffer", 0);
+      if (!client.GetData("inTrade"))
+      {
+        ChatService.ErrorMessage(client, "Das Handelsangebot ist abgelaufen.");
+        return;
+      }
+      string name = client.GetData("trade");
+      Client target = ClientService.GetClientByNameOrId(name);
+      if (target == null || !target.IsLoggedIn())
+      {
+        ChatService.PlayerNotFound(client);
+        return;
+      }
+
+      client.SetData("inTrade", false);
+      target.SetData("inTrade", false);
+      SendBackToSender(target);
+    }
+
+    public static void OpenTradeAccept(Client client)
+    {
+      User user = client.GetUser();
+      int id = client.GetData("tradePartner");
+      (int[] itemIdArr, int[] itemAmountArr) = TradeItems[id];
+      Timer tradeTimer = TradeTimer[id];
+      tradeTimer.Stop();
+      tradeTimer.Start();
+      client.TriggerEvent("openTradeWindow", TradeValue[id], itemIdArr, itemAmountArr);
+    }
+
+    [RemoteEvent("acceptTrade")]
+    public void ServerEvent_AcceptTrade(Client client)
+    {
+      if (!client.GetData("inTrade"))
+      {
+        ChatService.ErrorMessage(client, "Das Handelsangebot ist abgelaufen.");
+        return;
+      }
+      client.SetSharedData("tradeOffer", 0);
+      client.SetData("inTrade", false);
+
+      User user = client.GetUser();
+      int id = client.GetData("tradePartner");
+      (int[] itemIdArr, int[] itemAmountArr) = TradeItems[id];
+      Timer tradeTimer = TradeTimer[id];
+      tradeTimer.Stop();
+      string name = client.GetData("trade");
+      Client target = ClientService.GetClientByNameOrId(name);
+      if (target == null || !target.IsLoggedIn())
+      {
+        ChatService.PlayerNotFound(client);
+        return;
+      }
+      target.SetData("inTrade", false);
+   
+      using (var context = new DatabaseContext())
+      {
+
+        int targetInvWeight = GetUserInventoryWeight(client);
+        int inventoryWeight = 0;
+        for (int i = 0; i < itemIdArr.Length; i++)
+        {
+          int itemId = itemIdArr[i];
+          int itemAmount = itemAmountArr[i];
+          UserItem uitem = context.UserItems.Where(u => u.UserId == user.Id && u.ItemId == itemId).FirstOrDefault();
+          IItem iItem = GetItemById(uitem.ItemId);
+          var currentItemWeight = iItem.Gewicht * itemAmount;
+          inventoryWeight += currentItemWeight;
+        }
+        if (((targetInvWeight + inventoryWeight) / 1000) > 40)
+        {
+          ChatService.ErrorMessage(client, "Handel kann nicht getätigt werden.");
+          return;
+        }
+
+        for (int x = 0; x < itemIdArr.Length; x++)
+        {
+          int itemId = itemIdArr[x];
+          int itemAmount = itemAmountArr[x];
+          UserItem item = context.UserItems.Where(u => u.UserId == user.Id && u.ItemId == itemId).FirstOrDefault();
+          if (item != null)
+          {
+            item.Amount += itemAmount;
+          }
+          else
+          {
+            var newItem = new UserItem
+            {
+              ItemId = itemId,
+              UserId = user.Id,
+              Amount = itemAmount,
+              Slot = -1
+            };
+
+            context.UserItems.Add(newItem);
+          }
+          context.SaveChanges();
+        }
+      }
+      ChatService.SendMessage(target, $"{client.Name} hat deine Anfrage angenommen.");
+
+    }
   }
 }