Esempio n. 1
0
    public NetHoldable MakeNetHoldable()
    {
        var netCopy = new NetHoldable();

        netCopy.Inlitialize(this);
        return(netCopy);
    }
Esempio n. 2
0
    public override void Initialize(NetItem item)
    {
        base.Initialize(item);
        NetHoldable hold = item as NetHoldable;

        Damage = hold.Damage;
        Type   = hold.Type;
    }
    public static void JsonObject(Packet packet)
    {
        int id = packet.ReadInt();

        if (!GameManager.players.ContainsKey(id))
        {
            return;
        }

        string json = packet.ReadString();
        JsonSerializerSettings settings = new JsonSerializerSettings {
            TypeNameHandling = TypeNameHandling.All
        };
        NetEntity jsonObj = JsonConvert.DeserializeObject <NetEntity>(json, settings);

        if (jsonObj is NetAnimator)
        {
            GameManager.players[id].Animator.Set(jsonObj as NetAnimator);
            return;
        }
        if (jsonObj is BuildingData)
        {
            GameManager.instance.SpawnStructure(jsonObj as BuildingData);
            return;
        }
        if (jsonObj is NetItem)
        {
            NetItem netItem = jsonObj as NetItem;
            if (netItem is Netwearable)
            {
                Netwearable netWear = netItem as Netwearable;
                Wearable    wear    = new Wearable();
                wear.Initialize(netWear);
                GameManager.instance.ChangeInventory(id, wear);
            }
            if (netItem is NetHoldable)
            {
                NetHoldable netHold = netItem as NetHoldable;
                Holdable    hold    = new Holdable();
                hold.Initialize(netHold);
                GameManager.instance.ChangeInventory(id, hold);
            }
            return;
        }
        if (jsonObj is NetLoot)
        {
            NetLoot netLoot = jsonObj as NetLoot;
            GameManager.instance.CheckLoot(netLoot);
        }
        if (jsonObj is NetInventory)
        {
            Debug.Log("update inventory");
        }
    }
Esempio n. 4
0
    public static void JsonPackate(int fromPlayer, Packet packet)
    {
        int    id   = packet.ReadInt();
        string json = packet.ReadString();
        JsonSerializerSettings settings = new JsonSerializerSettings {
            TypeNameHandling = TypeNameHandling.All
        };
        NetEntity netPackage = JsonConvert.DeserializeObject <NetEntity>(json, settings);

        if (netPackage is BuildingData)
        {
            NetworkManager.instance.ConstructionControl.BuildBuilding(id, (BuildingData)netPackage);
        }
        if (netPackage is NetItem)
        {
            NetItem netItem = netPackage as NetItem;

            if (netItem is Netwearable)
            {
                Netwearable netWear = netItem as Netwearable;
                NetworkManager.instance.InventoryControl.ChangeWear(netWear, id);
            }
            if (netItem is NetHoldable)
            {
                NetHoldable netHold = netItem as NetHoldable;
                Debug.Log($"got holdable: {netHold.Name}");
            }
        }
        if (netPackage is NetLoot)
        {
            NetLoot netLoot = netPackage as NetLoot;

            if (netLoot.ownerID == -1)
            {
                NetworkManager.instance.LootControl.UpdateLoot(netLoot);
            }
            else
            {
                NetworkManager.instance.InventoryControl.TakeLoot(netLoot);
            }
        }
    }
Esempio n. 5
0
    public List <Item> GetItems()
    {
        List <Item> items = new List <Item>();

        foreach (var item in Items)
        {
            if (item is Netwearable)
            {
                Netwearable netWear  = item as Netwearable;
                Wearable    wearable = new Wearable();
                wearable.Initialize(netWear);
                items.Add(wearable);
            }
            if (item is NetHoldable)
            {
                NetHoldable netHold  = item as NetHoldable;
                Holdable    holdable = new Holdable();
                holdable.Initialize(netHold);
                items.Add(holdable);
            }
            if (item is NetConsumable)
            {
                NetConsumable netCons    = item as NetConsumable;
                Consumable    consumable = new Consumable();
                consumable.Initialize(netCons);
                items.Add(consumable);
            }
            if (item is NetMisc)
            {
                NetMisc netMisc = item as NetMisc;
                Misc    misc    = new Misc();
                misc.Initialize(netMisc);
                items.Add(misc);
            }
        }

        return(items);
    }