Example #1
0
        public override VobSendFlags Read(RakNet.BitStream stream)
        {
            VobSendFlags sendFlags = base.Read(stream);

            if (sendFlags.HasFlag(VobSendFlags.FocusName))
            {
                stream.Read(out focusName);
            }
            if (sendFlags.HasFlag(VobSendFlags.State))
            {
                stream.Read(out state);
            }
            if (sendFlags.HasFlag(VobSendFlags.UseWithItem))
            {
                int instanceID = 0;
                stream.Read(out instanceID);
                ItemInstance ii = ItemInstance.ItemInstanceDict[instanceID];
                this.useWithItem = ii;
            }
            if (sendFlags.HasFlag(VobSendFlags.TriggerTarget))
            {
                stream.Read(out triggerTarget);
            }

            return(sendFlags);
        }
        public override VobSendFlags Read(RakNet.BitStream stream)
        {
            VobSendFlags b = base.Read(stream);

            if (b.HasFlag(VobSendFlags.MCItemList))
            {
                int itemCount = 0;
                stream.Read(out itemCount);
                for (int i = 0; i < itemCount; i++)
                {
                    int itemID = 0;
                    stream.Read(out itemID);

                    if (!sWorld.VobDict.ContainsKey(itemID))
                    {
                        throw new Exception("Item was not found! :" + itemID);
                    }

                    Item itm = (Item)sWorld.VobDict[itemID];
                    addItem(itm);
                }
            }

            return(b);
        }
        public override VobSendFlags Write(RakNet.BitStream stream)
        {
            VobSendFlags sendFlags = base.Write(stream);

            if (sendFlags.HasFlag(VobSendFlags.IsLocked))
            {
                stream.Write(IsLocked);
            }
            if (sendFlags.HasFlag(VobSendFlags.KeyInstance))
            {
                stream.Write(KeyInstance.ID);
            }
            if (sendFlags.HasFlag(VobSendFlags.PickLockStr))
            {
                stream.Write(PickLockStr);
            }

            return(sendFlags);
        }
        public override VobSendFlags Read(RakNet.BitStream stream)
        {
            VobSendFlags sendFlags = base.Read(stream);

            if (sendFlags.HasFlag(VobSendFlags.IsLocked))
            {
                stream.Read(out isLocked);
            }
            if (sendFlags.HasFlag(VobSendFlags.KeyInstance))
            {
                int keyID = 0;
                stream.Read(out keyID);
                KeyInstance = ItemInstance.ItemInstanceDict[keyID];
            }
            if (sendFlags.HasFlag(VobSendFlags.PickLockStr))
            {
                stream.Read(out pickLockStr);
            }

            return(sendFlags);
        }
        public virtual VobSendFlags Write(BitStream stream)
        {
            VobSendFlags sendInfo = getSendInfo();

            stream.Write(ID);
            stream.Write((int)sendInfo);

            if (sendInfo.HasFlag(VobSendFlags.Visual))
            {
                stream.Write(Visual);
            }
            if (sendInfo.HasFlag(VobSendFlags.CDDyn))
            {
                stream.Write(CDDyn);
            }
            if (sendInfo.HasFlag(VobSendFlags.CDStatic))
            {
                stream.Write(CDStatic);
            }
            return(sendInfo);
        }
        public override VobSendFlags Write(RakNet.BitStream stream)
        {
            VobSendFlags sendFlags = base.Write(stream);

            if (sendFlags.HasFlag(VobSendFlags.FocusName))
            {
                stream.Write(focusName);
            }
            if (sendFlags.HasFlag(VobSendFlags.State))
            {
                stream.Write(state);
            }
            if (sendFlags.HasFlag(VobSendFlags.UseWithItem))
            {
                stream.Write(useWithItem.ID);
            }
            if (sendFlags.HasFlag(VobSendFlags.TriggerTarget))
            {
                stream.Write(triggerTarget);
            }
            return(sendFlags);
        }
        public override Vob.VobSendFlags Write(RakNet.BitStream stream)
        {
            VobSendFlags b = base.Write(stream);

            if (b.HasFlag(VobSendFlags.MCItemList))
            {
                stream.Write(this.itemList.Count);
                for (int i = 0; i < this.itemList.Count; i++)
                {
                    stream.Write(this.itemList[i].ID);
                }
            }

            return(b);
        }
Example #8
0
        public virtual VobSendFlags Read(BitStream stream)
        {
            int          sendInfo     = 0;
            VobSendFlags sendInfoFlag = 0;

            stream.Read(out _id);
            stream.Read(out sendInfo);

            sendInfoFlag = (VobSendFlags)sendInfo;

            if (sendInfoFlag.HasFlag(VobSendFlags.Visual))
            {
                stream.Read(out visual);
            }
            if (sendInfoFlag.HasFlag(VobSendFlags.CDDyn))
            {
                stream.Read(out _CDDyn);
            }
            if (sendInfoFlag.HasFlag(VobSendFlags.CDStatic))
            {
                stream.Read(out _CDStatic);
            }
            return(sendInfoFlag);
        }