/// <summary> /// Mount the accessory to the specified location. /// </summary> /// <remarks> /// <para> /// Remounting to a different or same location is allowed. If a remount fails the accessory will be /// released. This behavior is due to the multiple actors involved. E.g. The outfit, accessory, and /// possibly a mounter. The outfit can't guarentee behavior of all actors, so it implements a behavior that /// is consistant. /// </para> /// </remarks> /// <param name="accessory">The accessory to mount. (Required)</param> /// <param name="locationType">The location to mount the accessory to.</param> /// <param name="ignoreRestrictions"> /// If true, ignore coverage restrictions and the value of <see cref="AccessoriesLimited"/>. /// </param> /// <param name="priorityMounter"> /// The mounter that should be tried before any other mounters. (Optional) /// </param> /// <param name="additionalCoverage"> /// Coverage to add to the accessory if it is successfully mounted, above and beyond any coverage inherent /// iin the accessory and/or mounter. /// </param> /// <returns>The result of the mount attempt.</returns> public abstract MountResult Mount(Accessory accessory, MountPointType locationType, bool ignoreRestrictions, IAccessoryMounter priorityMounter, BodyCoverage additionalCoverage);
void IOutfitObserver.OnMountAccessory(Outfit sender, Accessory accessory) { // Do nothing. }
void IOutfitObserver.OnReleaseAccessory(Outfit sender, Accessory accessory) { // Do nothing. }
public abstract bool CanMount(Accessory accessory, MountPoint location);
public virtual void OnAccessoryDestroy(Accessory accessory, DestroyType type) { // Do nothing. // For most scriptable object mounters the main purpose for this is state cleanup of in-progress mounts. // So likelihood of use is similar to CancelMount. }
/// <summary> /// Mount the accessory to the specified location. /// </summary> /// <remarks> /// <para> /// Remounting to a different or same location is allowed. If a remount fails the accessory will be /// released. This behavior is due to the multiple actors involved. E.g. The outfit, accessory, and /// possibly a mounter. The outfit can't guarentee behavior of all actors, so it implements a behavior that /// is consistant. /// </para> /// </remarks> /// <param name="accessory">The accessory to mount. (Required)</param> /// <param name="locationType">The location to mount the accessory to.</param> /// <returns>The result of the mount attempt.</returns> public MountResult Mount(Accessory accessory, MountPointType locationType) { return(Mount(accessory, locationType, false, null, 0)); }
//////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// Unmount and release the the accessory. /// </summary> /// <remarks> /// <para> /// The release operation will always succeed if the accessory is is known to the outfit. /// </para> /// <para> /// This method can be called lazily. It will only take action if the accessory is known to the outfit. /// </para> /// </remarks> /// <param name="accessory">The accessory. (Required.)</param> /// <returns>True if an release occurred, false if the accessory is not known to the outfit.</returns> public abstract bool Release(Accessory accessory);
public abstract bool CanMount(Accessory accessory, MountPointType locationType);
public abstract bool InitializeMount(Accessory accessory, MountPoint location);
public override bool CanMount(Accessory accessory, MountPointType locationType) { return(accessory && locationType == m_Location); }
public override bool UpdateMount(Accessory accessory, MountPoint location, bool immediateComplete) { FinalizeMount(accessory, location.transform); return(false); }
void IOutfitObserver.OnReleaseAccessory(Outfit sender, Accessory accessory) { // Handled by accesory manager. }
public override bool RemoveAccessory(Accessory accessory) { CheckAccessoriesInitialized(); CheckNeedsSoftReset(); return(m_Accessories.Remove(accessory)); }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// public abstract bool UpdateMount(Accessory accessory, MountPoint location, float deltaTime);
//////////////////////////////////////////////////////////////////////////////////////////// // HACK: Unity 5.3.1: Workaround for Mono's optional parameter key duplication bug. /// <summary> /// Mount the accessory to the specified location. /// </summary> /// <remarks> /// <para> /// Remounting to a different or same location is allowed. If a remount fails the accessory will be /// released. This behavior is due to the multiple actors involved. E.g. The outfit, accessory, and /// possibly a mounter. The outfit can't guarentee behavior of all actors, so it implements a behavior that /// is consistant. /// </para> /// </remarks> /// <param name="accessory">The accessory to mount. (Required)</param> /// <param name="locationType">The location to mount the accessory to.</param> /// <param name="ignoreRestrictions"> /// If true, ignore coverage restrictions and the value of <see cref="AccessoriesLimited"/>. /// </param> /// <param name="priorityMounter"> /// The mounter that should be tried before any other mounters. (Optional) /// </param> /// <returns>The result of the mount attempt.</returns> public MountResult Mount(Accessory accessory, MountPointType locationType, bool ignoreRestrictions, IAccessoryMounter priorityMounter) { return(Mount(accessory, locationType, ignoreRestrictions, priorityMounter, 0)); }
public abstract bool UpdateMount(Accessory accessory, MountPoint location, bool immediateComplete);
/// <summary> /// Mount the accessory to the specified location. /// </summary> /// <remarks> /// <para> /// Remounting to a different or same location is allowed. If a remount fails the accessory will be /// released. This behavior is due to the multiple actors involved. E.g. The outfit, accessory, and /// possibly a mounter. The outfit can't guarentee behavior of all actors, so it implements a behavior that /// is consistant. /// </para> /// </remarks> /// <param name="accessory">The accessory to mount. (Required)</param> /// <param name="locationType">The location to mount the accessory to.</param> /// <param name="ignoreRestrictions"> /// If true, ignore coverage restrictions and the value of <see cref="AccessoriesLimited"/>. /// </param> /// <returns>The result of the mount attempt.</returns> public MountResult Mount(Accessory accessory, MountPointType locationType, bool ignoreRestrictions) { return(Mount(accessory, locationType, ignoreRestrictions, null, 0)); }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// // HACK: Unity 5.3.1: Workaround for Mono's optional parameter key duplication bug. public bool UpdateMount(Accessory accessory, MountPoint location) { return(UpdateMount(accessory, location, false)); }
/// <summary> /// Mount the accessory to its default location. /// </summary> /// <remarks> /// <para> /// Remounting to a different or same location is allowed. If a remount fails the accessory will be /// released. This behavior is due to the multiple actors involved. E.g. The outfit, accessory, and /// possibly a mounter. The outfit can't guarentee behavior of all actors, so it implements a behavior that /// is consistant. /// </para> /// </remarks> /// <param name="accessory">The accessory to mount. (Required)</param> /// <returns>The result of the mount attempt.</returns> public MountResult Mount(Accessory accessory) { return(Mount(accessory, accessory.DefaultLocationType, false, null)); }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// public virtual void CancelMount(Accessory accessory, MountPoint location) { // Do nothing. // Most mounters are expected to be immediate-complete. So don't make them all implement this method. }
private void SendUnmount(Accessory accessory) { Observers.SendRelease(this, accessory); }
private void LinkAccessory(Accessory accessory) { accessory.AddObserver(this); m_Accessories.Add(accessory); }