Example #1
0
 public override void Serialize(Bitstream msg)
 {
     msg.Write(Name);
     msg.WriteVariableUInt32(EntityId);
     msg.Write(Parameters.Count);
     foreach (var p in Parameters)
     {
         WriteParam(p, msg);
     }
 }
Example #2
0
        private static void WriteParam(object o, Bitstream msg)
        {
            var t = o.GetType();
            var dsitem = new DataSerializationProperty(null, t);

            msg.Write(t.FullName);
            switch (dsitem.Type)
            {
                case DataTypes.BOOL:
                    msg.Write((bool)o);
                    break;
                case DataTypes.UBYTE:
                    msg.Write((byte)o);
                    break;
                case DataTypes.UINT:
                    msg.WriteVariableUInt32((uint)o);
                    break;
                case DataTypes.BYTE:
                    msg.Write((sbyte)o);
                    break;
                case DataTypes.INT:
                    msg.WriteVariableInt32((int)o);
                    break;
                case DataTypes.ULONG:
                    msg.Write((ulong)o);
                    break;
                case DataTypes.LONG:
                    msg.Write((long)o);
                    break;
                case DataTypes.FLOAT:
                    msg.Write((float)o);
                    break;
                case DataTypes.DOUBLE:
                    msg.Write((double)o);
                    break;
                case DataTypes.STRING:
                    msg.Write((string)o);
                    break;
                case DataTypes.VECTOR2:
                    msg.Write((Vector2)o);
                    break;
                default:
                    throw new ArgumentException("Invalid RPC paramter type.");
            }
        }
Example #3
0
        public override void Serialize(Bitstream msg)
        {
            var count = State.Count;
            msg.Write((ushort)State.Count);
            if (count > 0 && _ownerType == null)
            {
                _ownerType = State[0].GetType();
                _lookupItem = DataLookupTable.Get(_ownerType.GetTypeInfo());
            }
            if (count > 0)
            {
                ushort objTypeId = ObjectMapper.LookupType(_ownerType);
                msg.Write((byte)objTypeId);
                msg.WriteVariableUInt32(PlayerId);
            }

            PlayerStateData pState = PreviousState;
            foreach (var o in State)
            {
                DataObjectPacket.WriteNetObject(_lookupItem, msg, o, pState);
                pState = o;
            }
        }
Example #4
0
 public override void Serialize(Bitstream msg)
 {
     msg.Write(OwnerEntityId);
     msg.Write(Success);
 }
Example #5
0
 public override void Serialize(Bitstream msg)
 {
     msg.Write(SimId);
 }
Example #6
0
        internal static void WriteNetObject(DataSerializationItem item, Bitstream msg, NetworkObject owner, NetworkObject baseline = null)
        {
            if (owner is DefinitionNetworkObject)
            {
                if ((owner as DefinitionNetworkObject).Destroy)
                {
                    msg.Write(true);
                    return;
                }
                else
                {
                    msg.Write(false);
                }
            }
            foreach (var prop in item.Properties)
            {
                if (UseBaseline(prop, owner, baseline))
                {
                    msg.Write(true);
                    continue;
                }
                else
                {
                    msg.Write(false);
                }

                switch (prop.Type)
                {
                    case DataTypes.BOOL:
                        var b = prop.Get<bool>(owner);
                        msg.Write(b);
                        break;
                    case DataTypes.UBYTE:
                        msg.Write(prop.Get<byte>(owner));
                        break;
                    case DataTypes.UINT:
                        msg.WriteVariableUInt32(prop.Get<uint>(owner));
                        break;
                    case DataTypes.BYTE:
                        msg.Write(prop.Get<sbyte>(owner));
                        break;
                    case DataTypes.INT:
                        msg.WriteVariableInt32(prop.Get<int>(owner));
                        break;
                    case DataTypes.ULONG:
                        msg.Write(prop.Get<ulong>(owner));
                        break;
                    case DataTypes.LONG:
                        msg.Write(prop.Get<long>(owner));
                        break;
                    case DataTypes.FLOAT:
                        msg.Write(prop.Get<float>(owner));
                        break;
                    case DataTypes.DOUBLE:
                        msg.Write(prop.Get<double>(owner));
                        break;
                    case DataTypes.STRING:
                        msg.Write(prop.Get<string>(owner));
                        break;
                    case DataTypes.VECTOR2:
                        msg.Write(prop.Get<Vector2>(owner));
                        break;
                    case DataTypes.NETPROP:
                        var childProp = prop.ChildProperty;
                        if (childProp != null)
                        {
                            var o = prop.Get<NetworkObject>(owner);

                            var baselinebackup = baseline;
                            if (baseline != null)
                            {
                                var childBase = prop.Get<NetworkObject>(baseline);
                                baseline = childBase;
                            }
                            WriteNetObject(childProp, msg, o, baseline);
                            baseline = baselinebackup;
                        }
                        break;
                }
            }
        }
Example #7
0
        public override void Serialize(Bitstream msg)
        {
            msg.Write(SnapId);
            msg.Write(BaselineId);
            msg.Write((byte)Objects.Count);
            foreach(var obj in Objects)
            {
                var ownerType = obj.Object.GetType().GetTypeInfo();
                ushort objTypeId = ObjectMapper.LookupType(ownerType);
                msg.Write((byte)objTypeId);
                msg.WriteVariableUInt32(obj.Lookup);

                var dItem = DataLookupTable.Get(ownerType);

                DeltaWrapper baseline = null;
                if (_baselineState != null)
                {
                    _baselineState.TryGetValue(obj.Object.GetHashCode(), out baseline);
                }

                NetworkObject baselineObj = null;
                if (baseline != null)
                {
                    uint offset = BaselineId - baseline.Lookup;
                    if (offset < Byte.MaxValue && baseline.Object != null)
                    {
                        msg.Write(true);
                        msg.Write((byte)offset);
                        baselineObj = baseline.Object;
                    }
                }

                if (baselineObj == null)
                {
                    msg.Write(false);
                }

                WriteNetObject(dItem, msg, obj.Object, baselineObj);
            }
        }