Beispiel #1
0
 private bool IsFirstAuthChange(Authority authToMatch, AuthorityChanges <Improbable.Gdk.Tests.AlternateSchemaSyntax.Connection.Component> changeOps)
 {
     foreach (var auth in changeOps.Changes)
     {
         if (auth != Authority.AuthorityLossImminent) // not relevant
         {
             return(auth == authToMatch);
         }
     }
     return(false);
 }
Beispiel #2
0
 private bool IsFirstAuthChange(Authority authToMatch, AuthorityChanges <Improbable.Gdk.Tests.ExhaustiveMapValue.Component> changeOps)
 {
     foreach (var auth in changeOps.Changes)
     {
         if (auth != Authority.AuthorityLossImminent) // not relevant
         {
             return(auth == authToMatch);
         }
     }
     return(false);
 }
Beispiel #3
0
 private bool IsFirstAuthChange(Authority authToMatch, AuthorityChanges <Generated.Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFields.Component> changeOps)
 {
     foreach (var auth in changeOps.Changes)
     {
         if (auth != Authority.AuthorityLossImminent) // not relevant
         {
             return(auth == authToMatch);
         }
     }
     return(false);
 }
            private void ApplyAuthorityChange(Unity.Entities.Entity entity, Authority authority, global::Improbable.Worker.EntityId entityId)
            {
                switch (authority)
                {
                case Authority.Authoritative:
                    if (!entityManager.HasComponent <NotAuthoritative <Improbable.Gdk.Tests.ExhaustiveOptional.Component> >(entity))
                    {
                        LogInvalidAuthorityTransition(Authority.Authoritative, Authority.NotAuthoritative, entityId);
                        return;
                    }

                    entityManager.RemoveComponent <NotAuthoritative <Improbable.Gdk.Tests.ExhaustiveOptional.Component> >(entity);
                    entityManager.AddComponent(entity, ComponentType.Create <Authoritative <Improbable.Gdk.Tests.ExhaustiveOptional.Component> >());

                    // Add event senders
                    break;

                case Authority.AuthorityLossImminent:
                    if (!entityManager.HasComponent <Authoritative <Improbable.Gdk.Tests.ExhaustiveOptional.Component> >(entity))
                    {
                        LogInvalidAuthorityTransition(Authority.AuthorityLossImminent, Authority.Authoritative, entityId);
                        return;
                    }

                    entityManager.AddComponent(entity, ComponentType.Create <AuthorityLossImminent <Improbable.Gdk.Tests.ExhaustiveOptional.Component> >());
                    break;

                case Authority.NotAuthoritative:
                    if (!entityManager.HasComponent <Authoritative <Improbable.Gdk.Tests.ExhaustiveOptional.Component> >(entity))
                    {
                        LogInvalidAuthorityTransition(Authority.NotAuthoritative, Authority.Authoritative, entityId);
                        return;
                    }

                    if (entityManager.HasComponent <AuthorityLossImminent <Improbable.Gdk.Tests.ExhaustiveOptional.Component> >(entity))
                    {
                        entityManager.RemoveComponent <AuthorityLossImminent <Improbable.Gdk.Tests.ExhaustiveOptional.Component> >(entity);
                    }

                    entityManager.RemoveComponent <Authoritative <Improbable.Gdk.Tests.ExhaustiveOptional.Component> >(entity);
                    entityManager.AddComponent(entity, ComponentType.Create <NotAuthoritative <Improbable.Gdk.Tests.ExhaustiveOptional.Component> >());

                    // Remove event senders
                    break;
                }

                List <Authority> authorityChanges;

                if (entityManager.HasComponent <AuthorityChanges <Improbable.Gdk.Tests.ExhaustiveOptional.Component> >(entity))
                {
                    authorityChanges = entityManager.GetComponentData <AuthorityChanges <Improbable.Gdk.Tests.ExhaustiveOptional.Component> >(entity).Changes;
                }
                else
                {
                    var changes = new AuthorityChanges <Improbable.Gdk.Tests.ExhaustiveOptional.Component>
                    {
                        Handle = AuthorityChangesProvider.Allocate(World)
                    };
                    AuthorityChangesProvider.Set(changes.Handle, new List <Authority>());
                    authorityChanges = changes.Changes;
                    entityManager.AddComponentData(entity, changes);
                }

                authorityChanges.Add(authority);
            }
            private void ApplyAuthorityChange(Unity.Entities.Entity entity, Authority authority, global::Improbable.Worker.EntityId entityId)
            {
                switch (authority)
                {
                case Authority.Authoritative:
                    if (!entityManager.HasComponent <NotAuthoritative <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents.Component> >(entity))
                    {
                        LogInvalidAuthorityTransition(Authority.Authoritative, Authority.NotAuthoritative, entityId);
                        return;
                    }

                    entityManager.RemoveComponent <NotAuthoritative <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents.Component> >(entity);
                    entityManager.AddComponent(entity, ComponentType.Create <Authoritative <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents.Component> >());

                    // Add event senders
                    {
                        var eventSender = new EventSender.Evt()
                        {
                            handle = ReferenceTypeProviders.EvtProvider.Allocate(World)
                        };
                        ReferenceTypeProviders.EvtProvider.Set(eventSender.handle, new List <global::Improbable.Gdk.Tests.ComponentsWithNoFields.Empty>());
                        entityManager.AddComponentData(entity, eventSender);
                    }
                    break;

                case Authority.AuthorityLossImminent:
                    if (!entityManager.HasComponent <Authoritative <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents.Component> >(entity))
                    {
                        LogInvalidAuthorityTransition(Authority.AuthorityLossImminent, Authority.Authoritative, entityId);
                        return;
                    }

                    entityManager.AddComponent(entity, ComponentType.Create <AuthorityLossImminent <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents.Component> >());
                    break;

                case Authority.NotAuthoritative:
                    if (!entityManager.HasComponent <Authoritative <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents.Component> >(entity))
                    {
                        LogInvalidAuthorityTransition(Authority.NotAuthoritative, Authority.Authoritative, entityId);
                        return;
                    }

                    if (entityManager.HasComponent <AuthorityLossImminent <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents.Component> >(entity))
                    {
                        entityManager.RemoveComponent <AuthorityLossImminent <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents.Component> >(entity);
                    }

                    entityManager.RemoveComponent <Authoritative <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents.Component> >(entity);
                    entityManager.AddComponent(entity, ComponentType.Create <NotAuthoritative <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents.Component> >());

                    // Remove event senders
                    {
                        var eventSender = entityManager.GetComponentData <EventSender.Evt>(entity);
                        ReferenceTypeProviders.EvtProvider.Free(eventSender.handle);
                        entityManager.RemoveComponent <EventSender.Evt>(entity);
                    }
                    break;
                }

                List <Authority> authorityChanges;

                if (entityManager.HasComponent <AuthorityChanges <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents.Component> >(entity))
                {
                    authorityChanges = entityManager.GetComponentData <AuthorityChanges <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents.Component> >(entity).Changes;
                }
                else
                {
                    var changes = new AuthorityChanges <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithEvents.Component>
                    {
                        Handle = AuthorityChangesProvider.Allocate(World)
                    };
                    AuthorityChangesProvider.Set(changes.Handle, new List <Authority>());
                    authorityChanges = changes.Changes;
                    entityManager.AddComponentData(entity, changes);
                }

                authorityChanges.Add(authority);
            }
            private void ApplyAuthorityChange(Unity.Entities.Entity entity, Authority authority, global::Improbable.Worker.EntityId entityId)
            {
                switch (authority)
                {
                case Authority.Authoritative:
                    if (!entityManager.HasComponent <NotAuthoritative <SpatialOSConnection> >(entity))
                    {
                        LogInvalidAuthorityTransition(Authority.Authoritative, Authority.NotAuthoritative, entityId);
                        return;
                    }

                    entityManager.RemoveComponent <NotAuthoritative <SpatialOSConnection> >(entity);
                    entityManager.AddComponentData(entity, new Authoritative <SpatialOSConnection>());

                    // Add event senders
                    {
                        var eventSender = new EventSender.MyEvent()
                        {
                            handle = ReferenceTypeProviders.MyEventProvider.Allocate(World)
                        };
                        ReferenceTypeProviders.MyEventProvider.Set(eventSender.handle, new List <global::Generated.Improbable.Gdk.Tests.AlternateSchemaSyntax.RandomDataType>());
                        entityManager.AddComponentData(entity, eventSender);
                    }
                    break;

                case Authority.AuthorityLossImminent:
                    if (!entityManager.HasComponent <Authoritative <SpatialOSConnection> >(entity))
                    {
                        LogInvalidAuthorityTransition(Authority.AuthorityLossImminent, Authority.Authoritative, entityId);
                        return;
                    }

                    entityManager.AddComponentData(entity, new AuthorityLossImminent <SpatialOSConnection>());
                    break;

                case Authority.NotAuthoritative:
                    if (!entityManager.HasComponent <Authoritative <SpatialOSConnection> >(entity))
                    {
                        LogInvalidAuthorityTransition(Authority.NotAuthoritative, Authority.Authoritative, entityId);
                        return;
                    }

                    if (entityManager.HasComponent <AuthorityLossImminent <SpatialOSConnection> >(entity))
                    {
                        entityManager.RemoveComponent <AuthorityLossImminent <SpatialOSConnection> >(entity);
                    }

                    entityManager.RemoveComponent <Authoritative <SpatialOSConnection> >(entity);
                    entityManager.AddComponentData(entity, new NotAuthoritative <SpatialOSConnection>());

                    // Remove event senders
                    {
                        var eventSender = entityManager.GetComponentData <EventSender.MyEvent>(entity);
                        ReferenceTypeProviders.MyEventProvider.Free(eventSender.handle);
                        entityManager.RemoveComponent <EventSender.MyEvent>(entity);
                    }
                    break;
                }

                List <Authority> authorityChanges;

                if (entityManager.HasComponent <AuthorityChanges <SpatialOSConnection> >(entity))
                {
                    authorityChanges = entityManager.GetComponentData <AuthorityChanges <SpatialOSConnection> >(entity).Changes;
                }
                else
                {
                    var changes = new AuthorityChanges <SpatialOSConnection>
                    {
                        Handle = AuthorityChangesProvider.Allocate(World)
                    };
                    AuthorityChangesProvider.Set(changes.Handle, new List <Authority>());
                    authorityChanges = changes.Changes;
                    entityManager.AddComponentData(entity, changes);
                }

                authorityChanges.Add(authority);
            }