Exemple #1
0
        public MessageProcessingResult Process(ItemEquippedMessage message, GameManager manager)
        {
            if (message.Successful)
            {
                foreach (var playerEntity in manager.Players)
                {
                    var actorSensed = manager.SensorySystem.CanSense(playerEntity, message.ActorEntity) ??
                                      SenseType.None;
                    if (message.SuppressLog ||
                        !message.ActorEntity.Being.IsAlive ||
                        actorSensed == SenseType.None)
                    {
                        continue;
                    }

                    var itemSensed = manager.SensorySystem.CanSense(playerEntity, message.ItemEntity) ?? SenseType.None;

                    var logMessage = manager.Game.Services.Language.GetString(new ItemEquipmentEvent(
                                                                                  playerEntity, message.ActorEntity, message.ItemEntity,
                                                                                  actorSensed, itemSensed, message.Slot));
                    WriteLog(logMessage, playerEntity, manager);
                }
            }

            return(MessageProcessingResult.ContinueProcessing);
        }
Exemple #2
0
        public MessageProcessingResult Process(ItemEquippedMessage message, GameManager manager)
        {
            if (message.Successful &&
                message.Delay != 0)
            {
                var ai = message.ActorEntity.AI;
                if (ai != null)
                {
                    ai.NextActionTick += message.Delay;
                }
            }

            return(MessageProcessingResult.ContinueProcessing);
        }
Exemple #3
0
        public MessageProcessingResult Process(ItemEquippedMessage message, GameManager manager)
        {
            if (!message.Successful)
            {
                return(MessageProcessingResult.ContinueProcessing);
            }

            if (message.Slot != EquipmentSlot.None)
            {
                var activation = CreateActivateAbilityMessage(manager);
                activation.ActivatorEntity = message.ActorEntity;
                activation.TargetEntity    = message.ActorEntity;

                if (ActivateAbilities(
                        message.ItemEntity.Id, ActivationType.WhileEquipped, activation, manager, pretend: true))
                {
                    ActivateAbilities(
                        message.ItemEntity.Id, ActivationType.WhileEquipped, activation, manager, pretend: false);
                    manager.ReturnMessage(activation);
                }
                else
                {
                    manager.ReturnMessage(activation);

                    var unequipMessage = manager.ItemUsageSystem.CreateEquipItemMessage(manager);
                    unequipMessage.ActorEntity = message.ActorEntity;
                    unequipMessage.ItemEntity  = message.ItemEntity;
                    unequipMessage.SuppressLog = true;

                    // TODO: Log message
                    manager.Enqueue(unequipMessage);
                    return(MessageProcessingResult.StopProcessing);
                }
            }
            else
            {
                DeactivateAbilities(message.ItemEntity.Id, ActivationType.WhileEquipped, message.ActorEntity, manager);
            }

            return(MessageProcessingResult.ContinueProcessing);
        }
Exemple #4
0
        public void TargetRpc_NotifyItemEquipped(NetworkConnection target, ItemEquippedMessage data)
        {
            logger.LogVerbose($"[Client] Server told us to equip item with ID {data.itemDefinitionID} to mountpoint {data.mountPoint}", this);

            var character = GetComponent <IEquippableCharacter <IEquippableItemInstance> >();

            if (character != null)
            {
                var mountPoint = character.mountPoints.FirstOrDefault(o => o.name == data.mountPoint);
                if (mountPoint != null)
                {
                    if (data.itemDefinitionID.guid == System.Guid.Empty)
                    {
                        mountPoint.Clear();
                    }
                    else
                    {
                        var item = itemsDatabase.Get(new Identifier(data.itemDefinitionID.guid));
                        if (item.error == null)
                        {
                            var equippable = item.result as IUnityEquippableItemDefinition;
                            if (equippable != null)
                            {
                                var inst = ItemFactory.CreateInstance(equippable, System.Guid.Empty) as IEquippableItemInstance;

                                mountPoint.Clear();
                                mountPoint.Mount(inst);
                            }
                        }
                        else
                        {
                            logger.Warning($"[Client] Server told us to equip item on this character; But item with ID {data.itemDefinitionID.guid} was not found.", this);
                        }
                    }
                }
                else
                {
                    logger.Warning($"[Client] Tried to visually equip item, but mountpoint with name {data.mountPoint} not found", this);
                }
            }
        }