示例#1
0
        /// <inheritdoc />
        protected override void HandleEvent(PlayerJoinedGroupEventArgs args)
        {
            //TODO: We need to check if we have one available
            //Claim a unitframe.
            GroupUnitframeManager.TryClaimUnitFrame(args.PlayerGuid);

            //Even if we don't know them, we should register an event for it.
            GroupUnitframeManager.RegisterCallback <int>(args.PlayerGuid, (int)EntityObjectField.UNIT_FIELD_HEALTH, OnCurrentHealthChangedValue);
            GroupUnitframeManager.RegisterCallback <int>(args.PlayerGuid, (int)BaseObjectField.UNIT_FIELD_LEVEL, OnCurrentLevelChanged);

            //TODO: If we come to know them after group join, we'll need to register.
            if (!EntityDataMappable.ContainsKey(args.PlayerGuid))
            {
                if (Logger.IsDebugEnabled)
                {
                    Logger.Debug($"Encountered GroupJoin from far-away Entity: {args.PlayerGuid.RawGuidValue}");
                }

                GroupUnitframeManager[args.PlayerGuid].SetElementActive(true);
                return;
            }
            else
            {
                //Very possible we don't know them
                //But if we do we should calculate their initial unitframe resources
                RecalulateHealthUI(args.PlayerGuid, EntityDataMappable.RetrieveEntity(args.PlayerGuid).GetFieldValue <int>((int)EntityObjectField.UNIT_FIELD_HEALTH));
                RecaculateLevelUI(args.PlayerGuid, EntityDataMappable.RetrieveEntity(args.PlayerGuid).GetFieldValue <int>((int)BaseObjectField.UNIT_FIELD_LEVEL));
                GroupUnitframeManager[args.PlayerGuid].SetElementActive(true);
            }
        }
示例#2
0
        public BaseEntityBehaviourComponent Create([NotNull] NetworkEntityGuid context)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }

            IEntityDataFieldContainer dataFieldContainer = EntityDataMappable.RetrieveEntity(context);
            GameObject worldObject = WorldObjectMappable.RetrieveEntity(context);

            Type behaviourType = ComputeExpectedBehaviourType(dataFieldContainer.GetEnumFieldValue <GameObjectType>(GameObjectField.GAMEOBJECT_TYPE_ID));

            using (var scope = ReflectionContainer.BeginLifetimeScope(cb =>
            {
                cb.RegisterInstance(context)
                .AsSelf();

                cb.RegisterInstance(worldObject)
                .As <GameObject>();

                cb.RegisterInstance(dataFieldContainer)
                .As <IEntityDataFieldContainer>()
                .As <IReadonlyEntityDataFieldContainer>()
                .SingleInstance();

                cb.RegisterType(behaviourType);
            }))
            {
                return((BaseEntityBehaviourComponent)scope.Resolve(behaviourType));
            }
        }
示例#3
0
        protected override void OnEntityCreationFinished(EntityCreationFinishedEventArgs args)
        {
            IEntityDataFieldContainer entityData          = EntityDataMappable.RetrieveEntity(args.EntityGuid);
            GameObjectTemplateModel   objectTemplateModel = GameObjectTemplateMappable.RetrieveEntity(args.EntityGuid);

            //We should generally consider this field static. I cannot even IMAGINE how we'd handle a change to this field on either
            //client or server.
            entityData.SetFieldValue(GameObjectField.GAMEOBJECT_TYPE_ID, (int)objectTemplateModel.ObjectType);
        }
示例#4
0
        private void OnTargetEntityHealthChanged(NetworkEntityGuid entity, EntityDataChangedArgs <int> args)
        {
            IEntityDataFieldContainer entityData = EntityDataMappable.RetrieveEntity(entity);

            //Ignore the changed value.
            int health    = entityData.GetFieldValue <int>(EntityObjectField.UNIT_FIELD_HEALTH);
            int maxHealth = entityData.GetFieldValue <int>(EntityObjectField.UNIT_FIELD_MAXHEALTH);

            TargetUnitFrame.HealthBar.BarText.Text           = $"{health} / {maxHealth}";
            TargetUnitFrame.HealthBar.BarFillable.FillAmount = (float)health / maxHealth;
        }
示例#5
0
        protected override void OnLocalPlayerTargetChanged(LocalPlayerTargetChangedEventArgs args)
        {
            IEntityDataFieldContainer entityData = EntityDataMappable.RetrieveEntity(args.TargetedEntity);

            EntityDataChangeCallbackService.RegisterCallback <int>(args.TargetedEntity, (int)BaseObjectField.UNIT_FIELD_LEVEL, OnTargetEntityLevelChanged);

            //Only initialize if we have their values
            if (entityData.DataSetIndicationArray.Get((int)BaseObjectField.UNIT_FIELD_LEVEL))
            {
                OnTargetEntityLevelChanged(args.TargetedEntity, new EntityDataChangedArgs <int>(0, entityData.GetFieldValue <int>(BaseObjectField.UNIT_FIELD_LEVEL)));
            }
        }
示例#6
0
        protected override void OnEventFired(object source, EntityCreationStartingEventArgs args)
        {
            //Only do creatures.
            if (args.EntityGuid.EntityType != EntityType.Creature)
            {
                return;
            }

            IEntityDataFieldContainer dataContainer = EntityDataMappable.RetrieveEntity(args.EntityGuid);
            CreatureTemplateModel     template      = CreatureTemplateMappable.RetrieveEntity(args.EntityGuid);

            //Initialize the creature display model ID.
            dataContainer.SetFieldValue(BaseObjectField.UNIT_FIELD_DISPLAYID, template.ModelId);
        }
示例#7
0
        protected override void OnLocalPlayerTargetChanged(LocalPlayerTargetChangedEventArgs args)
        {
            IEntityDataFieldContainer entityData = EntityDataMappable.RetrieveEntity(args.TargetedEntity);

            foreach (var unreg in Unregisterables)
            {
                unreg.Unregister();
            }

            Unregisterables.Clear();

            //Listen for both max and current health.
            Unregisterables.Add(EntityDataChangeCallbackService.RegisterCallback <int>(args.TargetedEntity, (int)EntityObjectField.UNIT_FIELD_HEALTH, OnTargetEntityHealthChanged));
            Unregisterables.Add(EntityDataChangeCallbackService.RegisterCallback <int>(args.TargetedEntity, (int)EntityObjectField.UNIT_FIELD_MAXHEALTH, OnTargetEntityHealthChanged));

            //Only initialize if we have their values
            if (entityData.DataSetIndicationArray.Get((int)EntityObjectField.UNIT_FIELD_HEALTH))
            {
                OnTargetEntityHealthChanged(args.TargetedEntity, new EntityDataChangedArgs <int>(0, 0));
            }
        }
示例#8
0
        /// <inheritdoc />
        public async Task SaveAsync(NetworkEntityGuid guid)
        {
            //We can only handle players at the moment, not sure how NPC data would be saved.
            if (guid.EntityType != EntityType.Player)
            {
                return;
            }

            //Player ALWAYS has this existing.
            EntitySaveableConfiguration saveConfig = PersistenceConfiguration.RetrieveEntity(guid);
            EntityFieldDataCollection   entityData = EntityDataMappable.RetrieveEntity(guid);

            await ZonePersistenceQueueable.SaveFullCharacterDataAsync(guid.EntityId, new FullCharacterDataSaveRequest(true, saveConfig.isCurrentPositionSaveable, CreatedLocationSaveData(guid), entityData));

            //We cleanup player data on the zoneserver in a different place
            //here, because we needed it until this very last moment.
            foreach (var ed in DataCollections)
            {
                ed.RemoveEntityEntry(guid);
            }
        }
示例#9
0
        private void CreateActor(WorldActorState state, CreateCreatureEntityActorMessage message)
        {
            //Create the actor and tell it to initialize.
            IActorRef actorRef = state.WorldActorFactory.ActorOf(Resolver.Create <DefaultCreatureEntityActor>(), message.EntityGuid.RawGuidValue.ToString());

            //TODO: Move to factory.
            CreatureInstanceModel instanceModel = CreatureInstanceMappable.RetrieveEntity(message.EntityGuid);
            CreatureTemplateModel templateModel = CreatureTemplateMappable.RetrieveEntity(message.EntityGuid);

            DefaultCreatureEntityActor.InitializeActor(actorRef, new DefaultCreatureActorState(EntityDataMappable.RetrieveEntity(message.EntityGuid), message.EntityGuid, instanceModel, templateModel, InterestMappable.RetrieveEntity(message.EntityGuid)));

            ActorRefMappable.AddObject(message.EntityGuid, actorRef);

            if (Logger.IsInfoEnabled)
            {
                Logger.Info($"Created Creature Actor: {typeof(DefaultCreatureEntityActor)} for Entity: {message.EntityGuid}");
            }
        }
示例#10
0
        private void RecalulateHealthUI(NetworkEntityGuid player, int currentHealth)
        {
            float healthPercentage = (float)currentHealth / EntityDataMappable[player].GetFieldValue <int>((int)EntityObjectField.UNIT_FIELD_MAXHEALTH);

            GroupUnitframeManager[player].HealthBar.BarFillable.FillAmount = healthPercentage;

            //Also we want to see the percentage text
            GroupUnitframeManager[player].HealthBar.BarText.Text = $"{currentHealth} / {EntityDataMappable.RetrieveEntity(player).GetFieldValue<int>((int)EntityObjectField.UNIT_FIELD_MAXHEALTH)}";
        }
示例#11
0
        private EntityActorStateInitializeMessage <BehaviourGameObjectState <TBehaviourType> > CreateState <TBehaviourType>(NetworkEntityGuid entityGuid)
            where TBehaviourType : class, IGameObjectLinkable
        {
            GameObjectTemplateModel templateModel = GameObjectDataContainer.GameObjectTemplateMappable.RetrieveEntity(entityGuid);
            GameObjectInstanceModel instanceModel = GameObjectDataContainer.GameObjectInstanceMappable.RetrieveEntity(entityGuid);

            return(new EntityActorStateInitializeMessage <BehaviourGameObjectState <TBehaviourType> >(new BehaviourGameObjectState <TBehaviourType>(EntityDataMappable.RetrieveEntity(entityGuid), entityGuid, instanceModel, templateModel, GameObjectDataContainer.GetBehaviourInstanceData <TBehaviourType>(entityGuid), InterestMappable.RetrieveEntity(entityGuid))));
        }
示例#12
0
        private IEntityActorStateInitializeMessage <DefaultGameObjectActorState> CreateDefaultInitializationState(NetworkEntityGuid entityGuid)
        {
            GameObjectTemplateModel templateModel = GameObjectDataContainer.GameObjectTemplateMappable.RetrieveEntity(entityGuid);
            GameObjectInstanceModel instanceModel = GameObjectDataContainer.GameObjectInstanceMappable.RetrieveEntity(entityGuid);

            return(new EntityActorStateInitializeMessage <DefaultGameObjectActorState>(new DefaultGameObjectActorState(EntityDataMappable.RetrieveEntity(entityGuid), entityGuid, instanceModel, templateModel, InterestMappable.RetrieveEntity(entityGuid))));
        }
示例#13
0
        private IActorRef CreateActor(WorldActorState state, CreatePlayerEntityActorMessage message)
        {
            //Create the actor and tell it to initialize.
            IActorRef actorRef = state.WorldActorFactory.ActorOf(Resolver.Create <DefaultPlayerEntityActor>(), message.EntityGuid.RawGuidValue.ToString());

            DefaultPlayerEntityActor.InitializeActor(actorRef, new DefaultPlayerEntityActorState(EntityDataMappable.RetrieveEntity(message.EntityGuid), message.EntityGuid, InterestMappable.RetrieveEntity(message.EntityGuid), SendServiceMappable.RetrieveEntity(message.EntityGuid)));

            //Actors aren't removed from this
            //they are just replaced with nobody.
            if (ActorRefMappable.ContainsKey(message.EntityGuid))
            {
                //If nobody, all good. Otherwise THIS SHOULD NEVER HAPPEN
                if (ActorRefMappable[message.EntityGuid].IsNobody())
                {
                    ActorRefMappable.ReplaceObject(message.EntityGuid, actorRef);
                }
                else
                {
                    throw new InvalidOperationException($"World attempted to spawn multiple of the same player actor/");                     //this will literally kill the world actor.
                }
            }
            else
            {
                ActorRefMappable.AddObject(message.EntityGuid, actorRef);
            }

            if (Logger.IsInfoEnabled)
            {
                Logger.Info($"Created Player Actor: {typeof(DefaultPlayerEntityActor)} for Entity: {message.EntityGuid}");
            }

            return(actorRef);
        }