pluginbase.Objects.Syncable.SyncableObject Class Reference

An object that acts as a base class for objects that want syncables as fields Most entities use this class More...

Inheritance diagram for pluginbase.Objects.Syncable.SyncableObject:

Protected Member Functions
	SyncableObject ()
	Initializes a new instance of the pluginbase.Objects.Syncable.SyncableObject class. More...
sealed override void	ResetWatch ()
	Reset variables watched status More...
sealed override void	TouchRecurse ()
	Touch self, including all children of this syncable object More...
sealed override void	EncodeTo (BinaryWriter writer, EncodeContext context)
	Encode changes to binary data More...
sealed override void	DecodeFrom (BinaryReader reader, DecodeContext context)
	Decode changes from binary data More...
sealed override void	Persist (IPersistObject obj)
	Build up a persistant object for this syncable, including all sync children and persist objects More...
sealed override void	Load (IReadPersistObject obj)
	Load a given persistent object back into this instance More...
Protected Member Functions inherited from pluginbase.Objects.Syncable.SyncableBase< SyncableObject >
void	Touch ()
	Touch the instance, notifying something has changed More...
virtual void	OnChanged ()
	Raises the changed event. More...
abstract void	Persist (IPersistObject obj)
	Persist the instance to a persist object More...
abstract void	Load (IReadPersistObject obj)
	Load the instance from a persist object More...

Properties
virtual ushort	NetOwnerId [get]
	Gets the network owner of this object (user id) More...

Additional Inherited Members
Events inherited from pluginbase.Objects.Syncable.SyncableBase< SyncableObject >
Action< T >	Changed
	Event triggered when any change occurs on this object, either locally or over the network More...
Action< T >	NetUpdate
	Event triggered when a change occurs resulting from a change over the network More...
Action< T >	Touched
	Event occurs only when an object is first touched. Usually the first instance of a local-change More...

Detailed Description

An object that acts as a base class for objects that want syncables as fields Most entities use this class

Constructor & Destructor Documentation

SyncableObject()

pluginbase.Objects.Syncable.SyncableObject.SyncableObject ( )

protected

Initializes a new instance of the pluginbase.Objects.Syncable.SyncableObject class.

Attribute: prop.Member.Name

= syncObject;

        {
            Type myType = this.GetType();

            var syncProperties = myType
                .GetAllMemberVars(x => Attribute.IsDefined(x, typeof(SyncableAttribute)))
                .OrderBy(x => x.Member.Name);

            if (syncProperties.Count() > MAX_SYNC_VAR_COUNT)
            {
                throw new Exception(string.Format("Syncable class {0} has exceeded max property count of {1}/{2}", myType.Name, syncProperties.Count(), MAX_SYNC_VAR_COUNT));
            }

            var watchList = new List<WatchItem>();
            foreach (ReflectionExtensions.UnifiedVariable prop in syncProperties)
            {
                if (!prop.IsField || !(prop.IsPrivate || prop.IsProtected) || !prop.IsReadonly)
                {
                    throw new Exception(string.Format("Syncable '{0}' must be a private/protected readonly field", prop.Member.Name));
                }

                SyncableAttribute attr = (SyncableAttribute)prop.Member.GetCustomAttributes(typeof(SyncableAttribute), true).Single();
                INetSyncable syncObject = prop.Getter(this) as INetSyncable;

                if (syncObject == null)
                {
                    syncObject = Activator.CreateInstance(prop.Type) as INetSyncable;
                }

                if (syncObject != null)
                {
                    //Setup the new syncable with this as the watcher
                    syncObject.ResetWatch(); //It is possible that something poked it during setup. We don't really care
                    syncObject.Watcher = this;
                    watchList.Add(new WatchItem{
                        Var = syncObject,
                        Attr = attr,
                        Name = prop.Member.Name,
                        OwnerProp = prop
                    });

                    prop.Setter(this, syncObject);

                    //Attach any validators
                    if (syncObject is IValidatedNetSyncable)
                    {
                        IValidatedNetSyncable validatedObject = syncObject as IValidatedNetSyncable;
                        IEnumerable<ValidateAttribute> propertyValidators = prop.Member.GetCustomAttributes(typeof(ValidateAttribute), true).Cast<ValidateAttribute>();

                        foreach(var validator in propertyValidators)
                        {
                            validatedObject.AddValidator(validator);
                        }
                    }

                    _namedVars[prop.Member.Name] = syncObject;
                }
                else
                {
                    throw new Exception(string.Format("Invalid watchable property {0} does not implement watchable interface", prop.Member.Name));
                }
            }
            _watchedVars = watchList.ToArray();


            //Collect up all persist items
            _persistVars = myType.GetAllMemberVars(x => Attribute.IsDefined(x, typeof(PersistAttribute))).ToArray();
        }

Member Function Documentation

DecodeFrom()

sealed override void pluginbase.Objects.Syncable.SyncableObject.DecodeFrom ( BinaryReader  reader, DecodeContext  context  )

protectedvirtual

Decode changes from binary data

Parameters

reader	Reader.
context	Context.

Attribute: varIndex

;

Implements pluginbase.Objects.Syncable.SyncableBase< SyncableObject >.

        {
            byte varIndex;
            while((varIndex = reader.ReadByte()) != byte.MaxValue)
            {
                if (varIndex < _watchedVars.Length)
                {
                    var watchable = _watchedVars[varIndex];

#if DEBUG
                    AssertWatchableValid(watchable);
#endif

                    if ( ShouldDecodeField(watchable, context ) )
                    {
                        watchable.Var.DecodeFrom(reader, context);
                        context.Increment();
                        if (context.Touch)
                        {
                            watchable.Var.Touch();
                        }
                    }
                    else
                    {
#if DEBUG
                        //In normal situations, this would be a hacker. In debug situations, this isn't good
                        throw new Exception(string.Format("Client {0} changed syncable that belonged to {1}; var {2}:{3}", context.FromId, this.NetOwnerId, varIndex, watchable.Name));
#else
                        context.Fail(); //Failing a packet will usually trigger the server resending the entity to the client to keep them in-sync
                        //Someone changed something they weren't supposed to
#endif
                    }
                }
                else
                {
#if DEBUG
                    //In normal situations, this might be a malformed packet. In debug situations, something broke
                    throw new Exception(string.Format("Syncable index higher than max objects {0}/{1}", varIndex, _watchedVars.Length));
#else
                    break;
#endif
                }
            }
        }

EncodeTo()

sealed override void pluginbase.Objects.Syncable.SyncableObject.EncodeTo ( BinaryWriter  writer, EncodeContext  context  )

protectedvirtual

Encode changes to binary data

Parameters

writer	Writer.
context	Context.

Attribute: i

; //alias

Implements pluginbase.Objects.Syncable.SyncableBase< SyncableObject >.

        {
            for (int i=0; i<_watchedVars.Length; ++i)
            {
                WatchItem watchable = _watchedVars[i]; //alias

#if DEBUG
                AssertWatchableValid(watchable);

                //Check in DEBUG if we actually own what we're changing
                //TODO: Disabled the ownership check for now because there's some logic in network pre-syncing that needs this
                //IE: We move an entity based on their physics client-side only with no expectation of syncing
                /*if (watchable.Var.Modified && !ContextOwnsField(watchable, context))
                {
                    throw new Exception(string.Format("Client {0} changed syncable that belongs to {1}; var {2}:{3}", context.EncodingId, this.NetOwnerId, i, watchable.Name));
                }*/
#endif

                if (ShouldEncodeField(watchable, context))
                {
                    writer.Write((byte)i);
                    watchable.Var.EncodeTo(writer, context);
                    context.Increment();
                }
            }

            writer.Write(byte.MaxValue); //terminator
        }

Load()

sealed override void pluginbase.Objects.Syncable.SyncableObject.Load ( IReadPersistObject  obj )

protected

Load a given persistent object back into this instance

Parameters

obj

Object.

Attribute: item.Member.Name

;

        {
            foreach(var item in _namedVars)
            {
                var sub = obj.GetObject(item.Key);
                if (sub != null)
                {
                    try
                    {
                        item.Value.Load(sub);
                    }
                    catch
                    {
#if DEBUG
                        throw;
#endif
                    }
                }
            }

            foreach(var item in _persistVars)
            {
                try
                {
                    if (obj.Has(item.Member.Name))
                    {
                        object o = obj[item.Member.Name];
                        if (!item.Type.IsInstanceOfType(o))
                        {
                            o = Convert.ChangeType(o, item.Type);
                        }
                        item.Setter(this, o);
                    }
                }
                catch
                {
#if DEBUG
                    throw;
#endif
                }
            }
        }

Persist()

sealed override void pluginbase.Objects.Syncable.SyncableObject.Persist ( IPersistObject  obj )

protected

Build up a persistant object for this syncable, including all sync children and persist objects

Parameters

obj

Object.

Attribute: item.Member.Name

= item.Getter(this);

        {
            foreach(var item in _namedVars)
            {
                try
                {
                    var sub = obj.GetOrCreateObject(item.Key);
                    item.Value.Persist(sub);
                }
                catch
                {
#if DEBUG
                    throw;
#endif
                }
            }

            foreach(var item in _persistVars)
            {
                try
                {
                    obj[item.Member.Name] = item.Getter(this);
                }
                catch
                {
#if DEBUG
                    throw;
#endif
                }
            }

        }

ResetWatch()

sealed override void pluginbase.Objects.Syncable.SyncableObject.ResetWatch ( )

protectedvirtual

Reset variables watched status

Reimplemented from pluginbase.Objects.Syncable.SyncableBase< SyncableObject >.

        {
            base.ResetWatch();
            foreach(WatchItem watchable in _watchedVars)
            {
                watchable.Var.ResetWatch();
            }
        }

TouchRecurse()

sealed override void pluginbase.Objects.Syncable.SyncableObject.TouchRecurse ( )

protectedvirtual

Touch self, including all children of this syncable object

Reimplemented from pluginbase.Objects.Syncable.SyncableBase< SyncableObject >.

        {
            base.TouchRecurse();
            foreach(WatchItem watchable in _watchedVars)
            {
                watchable.Var.TouchRecurse();
            }
        }

Property Documentation

NetOwnerId

virtual ushort pluginbase.Objects.Syncable.SyncableObject.NetOwnerId

getprotected

Gets the network owner of this object (user id)

The net owner identifier.

---

The documentation for this class was generated from the following file:

• pluginbase/Objects/Syncable/SyncableObject.cs