865 lines
35 KiB
C#
865 lines
35 KiB
C#
using Barotrauma.Networking;
|
|
using Barotrauma.Sounds;
|
|
using Microsoft.Xna.Framework;
|
|
using Microsoft.Xna.Framework.Graphics;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using Barotrauma.IO;
|
|
using System.Linq;
|
|
using System.Xml.Linq;
|
|
|
|
namespace Barotrauma.Items.Components
|
|
{
|
|
enum SoundSelectionMode
|
|
{
|
|
Random,
|
|
CharacterSpecific,
|
|
ItemSpecific,
|
|
All,
|
|
Manual
|
|
}
|
|
|
|
class ItemSound
|
|
{
|
|
public readonly RoundSound RoundSound;
|
|
public readonly ActionType Type;
|
|
|
|
public Identifier VolumeProperty;
|
|
|
|
public float VolumeMultiplier
|
|
{
|
|
get { return RoundSound.Volume; }
|
|
}
|
|
|
|
public float Range
|
|
{
|
|
get { return RoundSound.Range; }
|
|
}
|
|
|
|
public readonly bool Loop;
|
|
|
|
public readonly bool OnlyPlayInSameSub;
|
|
|
|
public ItemSound(RoundSound sound, ActionType type, bool loop = false, bool onlyPlayInSameSub = false)
|
|
{
|
|
this.RoundSound = sound;
|
|
this.Type = type;
|
|
this.Loop = loop;
|
|
this.OnlyPlayInSameSub = onlyPlayInSameSub;
|
|
}
|
|
}
|
|
|
|
partial class ItemComponent : ISerializableEntity
|
|
{
|
|
public bool HasSounds
|
|
{
|
|
get { return sounds.Count > 0; }
|
|
}
|
|
|
|
public bool[] HasSoundsOfType { get { return hasSoundsOfType; } }
|
|
|
|
private readonly bool[] hasSoundsOfType;
|
|
private readonly Dictionary<ActionType, List<ItemSound>> sounds;
|
|
private Dictionary<ActionType, SoundSelectionMode> soundSelectionModes;
|
|
|
|
/// <summary>
|
|
/// Starts the timer for delayed client-side corrections (<see cref="StartDelayedCorrection(IReadMessage, float, bool)"/>) - in other words,
|
|
/// the client will not attempt to read server updates for this component until the timer elapses.
|
|
/// </summary>
|
|
protected float correctionTimer;
|
|
|
|
public float IsActiveTimer;
|
|
|
|
public virtual bool RecreateGUIOnResolutionChange => false;
|
|
|
|
public GUILayoutSettings DefaultLayout { get; protected set; }
|
|
public GUILayoutSettings AlternativeLayout { get; protected set; }
|
|
|
|
public class GUILayoutSettings
|
|
{
|
|
public Vector2? RelativeSize { get; private set; }
|
|
public Point? AbsoluteSize { get; private set; }
|
|
public Vector2? RelativeOffset { get; private set; }
|
|
public Point? AbsoluteOffset { get; private set; }
|
|
public Anchor? Anchor { get; private set; }
|
|
public Pivot? Pivot { get; private set; }
|
|
|
|
public static GUILayoutSettings Load(XElement element)
|
|
{
|
|
var layout = new GUILayoutSettings();
|
|
var relativeSize = XMLExtensions.GetAttributeVector2(element, "relativesize", Vector2.Zero);
|
|
var absoluteSize = XMLExtensions.GetAttributePoint(element, "absolutesize", new Point(-1000, -1000));
|
|
var relativeOffset = XMLExtensions.GetAttributeVector2(element, "relativeoffset", Vector2.Zero);
|
|
var absoluteOffset = XMLExtensions.GetAttributePoint(element, "absoluteoffset", new Point(-1000, -1000));
|
|
if (relativeSize.Length() > 0)
|
|
{
|
|
layout.RelativeSize = relativeSize;
|
|
}
|
|
if (absoluteSize.X > 0 && absoluteSize.Y > 0)
|
|
{
|
|
layout.AbsoluteSize = absoluteSize;
|
|
}
|
|
if (relativeOffset.Length() > 0)
|
|
{
|
|
layout.RelativeOffset = relativeOffset;
|
|
}
|
|
if (absoluteOffset.X > -1000 && absoluteOffset.Y > -1000)
|
|
{
|
|
layout.AbsoluteOffset = absoluteOffset;
|
|
}
|
|
if (Enum.TryParse(XMLExtensions.GetAttributeString(element, "anchor", ""), out Anchor a))
|
|
{
|
|
layout.Anchor = a;
|
|
}
|
|
if (Enum.TryParse(XMLExtensions.GetAttributeString(element, "pivot", ""), out Pivot p))
|
|
{
|
|
layout.Pivot = p;
|
|
}
|
|
return layout;
|
|
}
|
|
|
|
public void ApplyTo(RectTransform target)
|
|
{
|
|
if (RelativeOffset.HasValue)
|
|
{
|
|
target.RelativeOffset = RelativeOffset.Value;
|
|
}
|
|
else if (AbsoluteOffset.HasValue)
|
|
{
|
|
target.AbsoluteOffset = AbsoluteOffset.Value;
|
|
}
|
|
if (RelativeSize.HasValue)
|
|
{
|
|
target.RelativeSize = RelativeSize.Value;
|
|
}
|
|
else if (AbsoluteSize.HasValue)
|
|
{
|
|
target.NonScaledSize = AbsoluteSize.Value;
|
|
}
|
|
if (Anchor.HasValue)
|
|
{
|
|
target.Anchor = Anchor.Value;
|
|
}
|
|
if (Pivot.HasValue)
|
|
{
|
|
target.Pivot = Pivot.Value;
|
|
}
|
|
else
|
|
{
|
|
target.Pivot = RectTransform.MatchPivotToAnchor(target.Anchor);
|
|
}
|
|
target.RecalculateChildren(true, true);
|
|
}
|
|
}
|
|
|
|
public GUIFrame GuiFrame { get; set; }
|
|
|
|
/// <summary>
|
|
/// Overlay (just a non-interactable sprite) drawn when the item is selected, equipped or focused to via Controllers (e.g. when operating a turret via a periscope or a camera via a monitor).
|
|
/// </summary>
|
|
public Sprite HUDOverlay { get; set; }
|
|
|
|
public float HUDOverlayAnimSpeed
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
private GUIDragHandle guiFrameDragHandle;
|
|
|
|
private bool guiFrameUpdatePending;
|
|
|
|
[Serialize(false, IsPropertySaveable.No)]
|
|
public bool AllowUIOverlap
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
[Serialize(true, IsPropertySaveable.No)]
|
|
public bool CloseByClickingOutsideGUIFrame
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
private ItemComponent linkToUIComponent;
|
|
[Serialize("", IsPropertySaveable.No)]
|
|
public string LinkUIToComponent
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
[Serialize(0, IsPropertySaveable.No)]
|
|
public int HudPriority
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
|
|
[Serialize(0, IsPropertySaveable.No)]
|
|
public int HudLayer
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
|
|
private bool useAlternativeLayout;
|
|
public bool UseAlternativeLayout
|
|
{
|
|
get { return useAlternativeLayout; }
|
|
set
|
|
{
|
|
if (AlternativeLayout != null)
|
|
{
|
|
if (value == useAlternativeLayout) { return; }
|
|
useAlternativeLayout = value;
|
|
if (useAlternativeLayout)
|
|
{
|
|
AlternativeLayout?.ApplyTo(GuiFrame.RectTransform);
|
|
}
|
|
else
|
|
{
|
|
DefaultLayout?.ApplyTo(GuiFrame.RectTransform);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool shouldMuffleLooping;
|
|
private float lastMuffleCheckTime;
|
|
private ItemSound loopingSound;
|
|
private SoundChannel loopingSoundChannel;
|
|
private readonly List<SoundChannel> playingOneshotSoundChannels = new List<SoundChannel>();
|
|
public ItemComponent ReplacedBy;
|
|
|
|
public ItemComponent GetReplacementOrThis()
|
|
{
|
|
if (ReplacedBy != null && ReplacedBy != this)
|
|
{
|
|
return ReplacedBy.GetReplacementOrThis();
|
|
}
|
|
return this;
|
|
}
|
|
|
|
public bool NeedsSoundUpdate()
|
|
{
|
|
if (hasSoundsOfType[(int)ActionType.Always]) { return true; }
|
|
if (loopingSoundChannel != null && loopingSoundChannel.IsPlaying) { return true; }
|
|
if (playingOneshotSoundChannels.Count > 0) { return true; }
|
|
return false;
|
|
}
|
|
|
|
public void UpdateSounds()
|
|
{
|
|
if (loopingSound != null && loopingSoundChannel != null && loopingSoundChannel.IsPlaying)
|
|
{
|
|
if (Timing.TotalTime > lastMuffleCheckTime + 0.2f)
|
|
{
|
|
shouldMuffleLooping = SoundPlayer.ShouldMuffleSound(Character.Controlled, item.WorldPosition, loopingSound.Range, Character.Controlled?.CurrentHull);
|
|
lastMuffleCheckTime = (float)Timing.TotalTime;
|
|
}
|
|
loopingSoundChannel.Muffled = shouldMuffleLooping;
|
|
float targetGain = GetSoundVolume(loopingSound);
|
|
float gainDiff = targetGain - loopingSoundChannel.Gain;
|
|
loopingSoundChannel.Gain += Math.Abs(gainDiff) < 0.1f ? gainDiff : Math.Sign(gainDiff) * 0.1f;
|
|
loopingSoundChannel.Position = new Vector3(item.WorldPosition, 0.0f);
|
|
loopingSound.RoundSound.LastStreamSeekPos = loopingSoundChannel.StreamSeekPos;
|
|
}
|
|
for (int i = 0; i < playingOneshotSoundChannels.Count; i++)
|
|
{
|
|
if (!playingOneshotSoundChannels[i].IsPlaying)
|
|
{
|
|
playingOneshotSoundChannels[i].Dispose();
|
|
playingOneshotSoundChannels[i] = null;
|
|
}
|
|
}
|
|
playingOneshotSoundChannels.RemoveAll(ch => ch == null);
|
|
foreach (SoundChannel channel in playingOneshotSoundChannels)
|
|
{
|
|
channel.Position = new Vector3(item.WorldPosition, 0.0f);
|
|
}
|
|
}
|
|
|
|
public void PlaySound(ActionType type, Character user = null)
|
|
{
|
|
if (!hasSoundsOfType[(int)type]) { return; }
|
|
if (GameMain.Client?.MidRoundSyncing ?? false) { return; }
|
|
|
|
//above the top boundary of the level (in an inactive respawn shuttle?)
|
|
if (item.Submarine != null && item.Submarine.IsAboveLevel)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (loopingSound != null)
|
|
{
|
|
if (Vector3.DistanceSquared(GameMain.SoundManager.ListenerPosition, new Vector3(item.WorldPosition, 0.0f)) > loopingSound.Range * loopingSound.Range ||
|
|
(GetSoundVolume(loopingSound)) <= 0.0001f)
|
|
{
|
|
if (loopingSoundChannel != null)
|
|
{
|
|
loopingSoundChannel.FadeOutAndDispose();
|
|
loopingSoundChannel = null;
|
|
loopingSound = null;
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (loopingSoundChannel != null && loopingSoundChannel.Sound != loopingSound.RoundSound.Sound)
|
|
{
|
|
loopingSoundChannel.FadeOutAndDispose();
|
|
loopingSoundChannel = null;
|
|
loopingSound = null;
|
|
}
|
|
|
|
if (loopingSoundChannel == null || !loopingSoundChannel.IsPlaying)
|
|
{
|
|
loopingSoundChannel = loopingSound.RoundSound.Sound.Play(
|
|
new Vector3(item.WorldPosition, 0.0f),
|
|
0.01f,
|
|
loopingSound.RoundSound.GetRandomFrequencyMultiplier(),
|
|
SoundPlayer.ShouldMuffleSound(Character.Controlled, item.WorldPosition, loopingSound.Range, Character.Controlled?.CurrentHull));
|
|
if (loopingSoundChannel != null)
|
|
{
|
|
loopingSoundChannel.Looping = true;
|
|
item.CheckNeedsSoundUpdate(this);
|
|
loopingSoundChannel.Near = loopingSound.Range * 0.4f;
|
|
loopingSoundChannel.Far = loopingSound.Range;
|
|
}
|
|
}
|
|
|
|
// Looping sound with manual selection mode should be changed if value of ManuallySelectedSound has changed
|
|
// Otherwise the sound won't change until the sound condition (such as being active) is disabled and re-enabled
|
|
if (loopingSoundChannel != null && loopingSoundChannel.IsPlaying && soundSelectionModes[type] == SoundSelectionMode.Manual)
|
|
{
|
|
var playingIndex = sounds[type].IndexOf(loopingSound);
|
|
var shouldBePlayingIndex = Math.Clamp(ManuallySelectedSound, 0, sounds[type].Count);
|
|
if (playingIndex != shouldBePlayingIndex)
|
|
{
|
|
loopingSoundChannel.FadeOutAndDispose();
|
|
loopingSoundChannel = null;
|
|
loopingSound = null;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
var matchingSounds = sounds[type];
|
|
if (loopingSoundChannel == null || !loopingSoundChannel.IsPlaying)
|
|
{
|
|
SoundSelectionMode soundSelectionMode = soundSelectionModes[type];
|
|
int index;
|
|
if (soundSelectionMode == SoundSelectionMode.CharacterSpecific && user != null)
|
|
{
|
|
index = user.ID % matchingSounds.Count;
|
|
}
|
|
else if (soundSelectionMode == SoundSelectionMode.ItemSpecific)
|
|
{
|
|
index = item.ID % matchingSounds.Count;
|
|
}
|
|
else if (soundSelectionMode == SoundSelectionMode.All)
|
|
{
|
|
foreach (ItemSound sound in matchingSounds)
|
|
{
|
|
PlaySound(sound, item.WorldPosition);
|
|
}
|
|
return;
|
|
}
|
|
else if (soundSelectionMode == SoundSelectionMode.Manual)
|
|
{
|
|
index = Math.Clamp(ManuallySelectedSound, 0, matchingSounds.Count - 1);
|
|
}
|
|
else
|
|
{
|
|
index = Rand.Int(matchingSounds.Count);
|
|
}
|
|
|
|
PlaySound(matchingSounds[index], item.WorldPosition);
|
|
item.CheckNeedsSoundUpdate(this);
|
|
}
|
|
}
|
|
private void PlaySound(ItemSound itemSound, Vector2 position)
|
|
{
|
|
if (Vector2.DistanceSquared(new Vector2(GameMain.SoundManager.ListenerPosition.X, GameMain.SoundManager.ListenerPosition.Y), position) > itemSound.Range * itemSound.Range)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (itemSound.OnlyPlayInSameSub && item.Submarine != null && Character.Controlled != null)
|
|
{
|
|
if (Character.Controlled.Submarine == null || !Character.Controlled.Submarine.IsEntityFoundOnThisSub(item, includingConnectedSubs: true)) { return; }
|
|
}
|
|
|
|
if (itemSound.Loop)
|
|
{
|
|
if (loopingSoundChannel != null && loopingSoundChannel.Sound != itemSound.RoundSound.Sound)
|
|
{
|
|
loopingSoundChannel.FadeOutAndDispose(); loopingSoundChannel = null;
|
|
}
|
|
if (loopingSoundChannel == null || !loopingSoundChannel.IsPlaying)
|
|
{
|
|
float volume = GetSoundVolume(itemSound);
|
|
if (volume <= 0.0001f) { return; }
|
|
loopingSound = itemSound;
|
|
loopingSoundChannel = SoundPlayer.PlaySound(loopingSound.RoundSound, position, volume: 0.01f, hullGuess: item.CurrentHull);
|
|
if (loopingSoundChannel != null)
|
|
{
|
|
loopingSoundChannel.Looping = true;
|
|
loopingSoundChannel.Near = loopingSound.Range * 0.4f;
|
|
loopingSoundChannel.Far = loopingSound.Range;
|
|
if (loopingSound.RoundSound.Stream)
|
|
{
|
|
loopingSoundChannel.StreamSeekPos = loopingSound.RoundSound.LastStreamSeekPos;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
float volume = GetSoundVolume(itemSound);
|
|
if (volume <= 0.0001f) { return; }
|
|
var channel = SoundPlayer.PlaySound(itemSound.RoundSound, position, volume, hullGuess: item.CurrentHull);
|
|
if (channel != null) { playingOneshotSoundChannels.Add(channel); }
|
|
}
|
|
}
|
|
|
|
public void StopLoopingSound()
|
|
{
|
|
if (loopingSound == null) { return; }
|
|
if (loopingSoundChannel != null)
|
|
{
|
|
loopingSoundChannel.FadeOutAndDispose();
|
|
loopingSoundChannel = null;
|
|
loopingSound = null;
|
|
}
|
|
}
|
|
|
|
public void StopSounds(ActionType type)
|
|
{
|
|
if (loopingSound == null || loopingSound.Type != type) { return; }
|
|
StopLoopingSound();
|
|
}
|
|
|
|
private float GetSoundVolume(ItemSound sound)
|
|
{
|
|
if (sound == null) { return 0.0f; }
|
|
if (sound.VolumeProperty == "") { return sound.VolumeMultiplier; }
|
|
|
|
SerializableProperty property = null;
|
|
ISerializableEntity targetEntity = null;
|
|
if (SerializableProperties.TryGetValue(sound.VolumeProperty, out property))
|
|
{
|
|
targetEntity = this;
|
|
}
|
|
else if (Item.SerializableProperties.TryGetValue(sound.VolumeProperty, out property))
|
|
{
|
|
targetEntity = Item;
|
|
}
|
|
|
|
if (property != null)
|
|
{
|
|
float newVolume;
|
|
try
|
|
{
|
|
newVolume = property.GetFloatValue(targetEntity);
|
|
}
|
|
catch
|
|
{
|
|
return 0.0f;
|
|
}
|
|
newVolume = Math.Min(newVolume * sound.VolumeMultiplier, 1.0f);
|
|
|
|
if (!MathUtils.IsValid(newVolume))
|
|
{
|
|
DebugConsole.Log("Invalid sound volume (item " + item.Name + ", " + GetType().ToString() + "): " + newVolume);
|
|
GameAnalyticsManager.AddErrorEventOnce(
|
|
"ItemComponent.PlaySound:" + item.Name + GetType().ToString(),
|
|
GameAnalyticsManager.ErrorSeverity.Error,
|
|
"Invalid sound volume (item " + item.Name + ", " + GetType().ToString() + "): " + newVolume);
|
|
return 0.0f;
|
|
}
|
|
|
|
return MathHelper.Clamp(newVolume, 0.0f, 1.0f);
|
|
}
|
|
|
|
return 0.0f;
|
|
}
|
|
|
|
public bool ShouldDrawHUD(Character character)
|
|
{
|
|
if (Character.Controlled?.SelectedItem != null)
|
|
{
|
|
Controller controller = item.GetComponent<Controller>();
|
|
if (controller != null && controller.User == Character.Controlled && controller.HideAllItemComponentHUDs)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return ShouldDrawHUDComponentSpecific(character);
|
|
}
|
|
|
|
protected virtual bool ShouldDrawHUDComponentSpecific(Character character)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public ItemComponent GetLinkUIToComponent()
|
|
{
|
|
if (string.IsNullOrEmpty(LinkUIToComponent))
|
|
{
|
|
return null;
|
|
}
|
|
foreach (ItemComponent component in item.Components)
|
|
{
|
|
if (component.name.Equals(LinkUIToComponent, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
linkToUIComponent = component;
|
|
}
|
|
}
|
|
if (linkToUIComponent == null)
|
|
{
|
|
DebugConsole.ThrowError("Failed to link the component \"" + Name + "\" to \"" + LinkUIToComponent + "\" in the item \"" + item.Name + "\" - component with a matching name not found.");
|
|
}
|
|
return linkToUIComponent;
|
|
}
|
|
|
|
public virtual void DrawHUD(SpriteBatch spriteBatch, Character character)
|
|
{
|
|
if (HUDOverlay != null)
|
|
{
|
|
Vector2 screenSize = new Vector2(GameMain.GraphicsWidth, GameMain.GraphicsHeight);
|
|
if (HUDOverlay is SpriteSheet spriteSheet)
|
|
{
|
|
spriteSheet.Draw(spriteBatch,
|
|
spriteIndex: spriteSheet.GetAnimatedSpriteIndex(HUDOverlayAnimSpeed),
|
|
pos: screenSize / 2, color: Color.White, origin: HUDOverlay.Origin, rotate: 0, scale: screenSize / spriteSheet.FrameSize.ToVector2());
|
|
}
|
|
else
|
|
{
|
|
HUDOverlay.Draw(spriteBatch,
|
|
pos: screenSize / 2, color: Color.White, origin: HUDOverlay.Origin, rotate: 0, scale: screenSize / HUDOverlay.size);
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual void AddToGUIUpdateList(int order = 0)
|
|
{
|
|
GuiFrame?.AddToGUIUpdateList(order: order);
|
|
}
|
|
|
|
public void UpdateHUD(Character character, float deltaTime, Camera cam)
|
|
{
|
|
UpdateHUDComponentSpecific(character, deltaTime, cam);
|
|
if (guiFrameUpdatePending && !PlayerInput.PrimaryMouseButtonHeld())
|
|
{
|
|
//send a guiframe position update once the player stops dragging the frame
|
|
guiFrameUpdatePending = false;
|
|
if (SerializableProperties.TryGetValue(nameof(GuiFrameOffset).ToIdentifier(), out var property))
|
|
{
|
|
GameMain.Client?.CreateEntityEvent(Item, new Item.ChangePropertyEventData(property, this));
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual void UpdateHUDComponentSpecific(Character character, float deltaTime, Camera cam) { }
|
|
|
|
public virtual void UpdateEditing(float deltaTime) { }
|
|
|
|
public virtual void CreateEditingHUD(SerializableEntityEditor editor)
|
|
{
|
|
}
|
|
|
|
private bool LoadElemProjSpecific(ContentXElement subElement)
|
|
{
|
|
switch (subElement.Name.ToString().ToLowerInvariant())
|
|
{
|
|
case "guiframe":
|
|
if (subElement.GetAttribute("rect") != null)
|
|
{
|
|
DebugConsole.ThrowError($"Error in item config \"{item.ConfigFilePath}\" - GUIFrame defined as rect, use RectTransform instead.",
|
|
contentPackage: subElement.ContentPackage);
|
|
break;
|
|
}
|
|
GuiFrameSource = subElement;
|
|
ReloadGuiFrame();
|
|
break;
|
|
case "hudoverlayanimated":
|
|
HUDOverlay = new SpriteSheet(subElement);
|
|
HUDOverlayAnimSpeed = subElement.GetAttributeFloat("animspeed", 1.0f);
|
|
break;
|
|
case "hudoverlay":
|
|
HUDOverlay = new Sprite(subElement);
|
|
break;
|
|
case "alternativelayout":
|
|
AlternativeLayout = GUILayoutSettings.Load(subElement);
|
|
break;
|
|
case "itemsound":
|
|
case "sound":
|
|
//TODO: this validation stuff should probably go somewhere else
|
|
string filePath = subElement.GetAttributeStringUnrestricted("file", "");
|
|
|
|
if (filePath.IsNullOrEmpty()) { filePath = subElement.GetAttributeStringUnrestricted("sound", ""); }
|
|
|
|
if (filePath.IsNullOrEmpty())
|
|
{
|
|
DebugConsole.ThrowError(
|
|
$"Error when instantiating item \"{item.Name}\" - sound with no file path set",
|
|
contentPackage: subElement.ContentPackage);
|
|
break;
|
|
}
|
|
|
|
ActionType type;
|
|
string typeStr = subElement.GetAttributeString("type", "");
|
|
try
|
|
{
|
|
type = (ActionType)Enum.Parse(typeof(ActionType), typeStr, true);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
DebugConsole.ThrowError($"Invalid sound type \"{typeStr}\" in item \"{item.Prefab.Identifier}\"!", e,
|
|
contentPackage: subElement.ContentPackage);
|
|
break;
|
|
}
|
|
|
|
RoundSound sound = RoundSound.Load(subElement);
|
|
if (sound == null) { break; }
|
|
ItemSound itemSound = new ItemSound(sound, type,
|
|
subElement.GetAttributeBool("loop", false),
|
|
subElement.GetAttributeBool("onlyinsamesub", false))
|
|
{
|
|
VolumeProperty = subElement.GetAttributeIdentifier("volumeproperty", "")
|
|
};
|
|
|
|
if (soundSelectionModes == null)
|
|
{
|
|
soundSelectionModes = new Dictionary<ActionType, SoundSelectionMode>();
|
|
}
|
|
if (!soundSelectionModes.ContainsKey(type) || soundSelectionModes[type] == SoundSelectionMode.Random)
|
|
{
|
|
soundSelectionModes[type] = subElement.GetAttributeEnum("selectionmode", SoundSelectionMode.Random);
|
|
}
|
|
|
|
if (!sounds.TryGetValue(itemSound.Type, out List<ItemSound> soundList))
|
|
{
|
|
soundList = new List<ItemSound>();
|
|
sounds.Add(itemSound.Type, soundList);
|
|
hasSoundsOfType[(int)itemSound.Type] = true;
|
|
}
|
|
|
|
soundList.Add(itemSound);
|
|
break;
|
|
default:
|
|
return false; //unknown element
|
|
}
|
|
return true; //element processed
|
|
}
|
|
|
|
private XElement GuiFrameSource;
|
|
|
|
protected void ReleaseGuiFrame()
|
|
{
|
|
if (GuiFrame != null)
|
|
{
|
|
GuiFrame.RectTransform.Parent = null;
|
|
}
|
|
}
|
|
|
|
protected void ReloadGuiFrame()
|
|
{
|
|
if (GuiFrame != null)
|
|
{
|
|
ReleaseGuiFrame();
|
|
}
|
|
Color? color = null;
|
|
if (GuiFrameSource.Attribute("color") != null)
|
|
{
|
|
color = GuiFrameSource.GetAttributeColor("color", Color.White);
|
|
}
|
|
string style = GuiFrameSource.Attribute("style") == null ? null : GuiFrameSource.GetAttributeString("style", "");
|
|
GuiFrame = new GUIFrame(RectTransform.Load(GuiFrameSource, GUI.Canvas, Anchor.Center), style, color);
|
|
GuiFrame.RectTransform.ScreenSpaceOffset = GuiFrameOffset;
|
|
|
|
TryCreateDragHandle();
|
|
|
|
DefaultLayout = GUILayoutSettings.Load(GuiFrameSource);
|
|
if (GuiFrame != null)
|
|
{
|
|
GuiFrame.RectTransform.ParentChanged += OnGUIParentChanged;
|
|
}
|
|
GameMain.Instance.ResolutionChanged += OnResolutionChangedPrivate;
|
|
}
|
|
|
|
protected void TryCreateDragHandle()
|
|
{
|
|
if (GuiFrame != null && GuiFrameSource.GetAttributeBool("draggable", true))
|
|
{
|
|
bool hideDragIcons = GuiFrameSource.GetAttributeBool("hidedragicons", false);
|
|
|
|
guiFrameDragHandle = new GUIDragHandle(new RectTransform(Vector2.One, GuiFrame.RectTransform, Anchor.Center),
|
|
GuiFrame.RectTransform, style: null)
|
|
{
|
|
Enabled = !LockGuiFramePosition,
|
|
DragArea = HUDLayoutSettings.ItemHUDArea
|
|
};
|
|
|
|
int iconHeight = GUIStyle.ItemFrameMargin.Y / 4;
|
|
var dragIcon = new GUIImage(new RectTransform(new Point(GuiFrame.Rect.Width, iconHeight), guiFrameDragHandle.RectTransform, Anchor.TopCenter) { AbsoluteOffset = new Point(0, iconHeight / 2) },
|
|
style: "GUIDragIndicatorHorizontal");
|
|
dragIcon.RectTransform.MinSize = new Point(0, iconHeight);
|
|
|
|
guiFrameDragHandle.ValidatePosition = (RectTransform rectT) =>
|
|
{
|
|
var activeHuds = Character.Controlled?.SelectedItem?.ActiveHUDs ?? item.ActiveHUDs;
|
|
foreach (ItemComponent ic in activeHuds)
|
|
{
|
|
if (ic == this || ic.GuiFrame == null || !ic.CanBeSelected) { continue; }
|
|
if (ic.GuiFrame.Rect.Width > GameMain.GraphicsWidth * 0.9f && ic.GuiFrame.Rect.Height > GameMain.GraphicsHeight * 0.9f)
|
|
{
|
|
//a full-screen GUIFrame (or at least close to one) - this component is doing something weird,
|
|
//an ItemContainer with no GUIFrame definition that positions itself in some other GUIFrame, some kind of an overlay?
|
|
// -> allow intersecting
|
|
continue;
|
|
}
|
|
if (dragIcon.Rect.Intersects(ic.GuiFrame.Rect))
|
|
{
|
|
GuiFrame.ImmediateFlash();
|
|
return false;
|
|
}
|
|
}
|
|
foreach (ItemComponent ic in activeHuds)
|
|
{
|
|
//refresh slots to ensure they're rendered at the correct position
|
|
(ic as ItemContainer)?.Inventory.CreateSlots();
|
|
}
|
|
GuiFrameOffset = GuiFrame.RectTransform.ScreenSpaceOffset;
|
|
guiFrameUpdatePending = true;
|
|
return true;
|
|
};
|
|
|
|
int buttonHeight = (int)(GUIStyle.ItemFrameMargin.Y * 0.4f);
|
|
var settingsIcon = new GUIButton(new RectTransform(new Point(buttonHeight), guiFrameDragHandle.RectTransform, Anchor.TopLeft) { AbsoluteOffset = new Point(buttonHeight / 4), MinSize = new Point(buttonHeight) },
|
|
style: "GUIButtonSettings")
|
|
{
|
|
OnClicked = (btn, userdata) =>
|
|
{
|
|
GUIContextMenu.CreateContextMenu(
|
|
new ContextMenuOption("item.resetuiposition", isEnabled: true, onSelected: () =>
|
|
{
|
|
foreach (var ic in item.Components)
|
|
{
|
|
if (ic.GuiFrame != null && ic.GuiFrameOffset != Point.Zero)
|
|
{
|
|
ic.GuiFrameOffset = Point.Zero;
|
|
ic.guiFrameUpdatePending = true;
|
|
}
|
|
}
|
|
if (Character.Controlled?.SelectedItem != null && item != Character.Controlled.SelectedItem)
|
|
{
|
|
Character.Controlled.SelectedItem.ForceHUDLayoutUpdate(ignoreLocking: true);
|
|
}
|
|
else
|
|
{
|
|
item.ForceHUDLayoutUpdate(ignoreLocking: true);
|
|
}
|
|
}),
|
|
new ContextMenuOption(TextManager.Get(LockGuiFramePosition ? "item.unlockuiposition" : "item.lockuiposition"), isEnabled: true, onSelected: () =>
|
|
{
|
|
//ensure the offset is set to where the frame is now
|
|
//(it may have been repositioned by the overlap prevention logic, which doesn't set this offset)
|
|
GuiFrameOffset = GuiFrame.RectTransform.ScreenSpaceOffset;
|
|
LockGuiFramePosition = !LockGuiFramePosition;
|
|
guiFrameDragHandle.Enabled = !LockGuiFramePosition;
|
|
if (SerializableProperties.TryGetValue(nameof(LockGuiFramePosition).ToIdentifier(), out var property))
|
|
{
|
|
GameMain.Client?.CreateEntityEvent(Item, new Item.ChangePropertyEventData(property, this));
|
|
}
|
|
}));
|
|
return true;
|
|
}
|
|
};
|
|
|
|
if (hideDragIcons)
|
|
{
|
|
dragIcon.Visible = false;
|
|
settingsIcon.Visible = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Overload this method and implement. The method is automatically called when the resolution changes.
|
|
/// </summary>
|
|
protected virtual void CreateGUI() { }
|
|
|
|
/// <summary>
|
|
/// Starts a coroutine that will read the correct state of the component from the NetBuffer when correctionTimer reaches zero.
|
|
/// Useful in cases where we a client is constantly adjusting some value, and we don't want state updates from the server to interfere with it
|
|
/// (e.g. setting the value back to what a client just set it to, when the client has already modified the value further).
|
|
/// </summary>
|
|
protected void StartDelayedCorrection(IReadMessage buffer, float sendingTime, bool waitForMidRoundSync = false)
|
|
{
|
|
if (delayedCorrectionCoroutine != null) { CoroutineManager.StopCoroutines(delayedCorrectionCoroutine); }
|
|
|
|
delayedCorrectionCoroutine = CoroutineManager.StartCoroutine(DoDelayedCorrection(buffer, sendingTime, waitForMidRoundSync));
|
|
}
|
|
|
|
private IEnumerable<CoroutineStatus> DoDelayedCorrection(IReadMessage buffer, float sendingTime, bool waitForMidRoundSync)
|
|
{
|
|
while (GameMain.Client != null &&
|
|
(correctionTimer > 0.0f || (waitForMidRoundSync && GameMain.Client.MidRoundSyncing)))
|
|
{
|
|
correctionTimer -= CoroutineManager.DeltaTime;
|
|
yield return CoroutineStatus.Running;
|
|
}
|
|
|
|
if (item.Removed || GameMain.Client == null)
|
|
{
|
|
yield return CoroutineStatus.Success;
|
|
}
|
|
|
|
((IServerSerializable)this).ClientEventRead(buffer, sendingTime);
|
|
|
|
correctionTimer = 0.0f;
|
|
delayedCorrectionCoroutine = null;
|
|
|
|
yield return CoroutineStatus.Success;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Launches when the parent of the GuiFrame is changed.
|
|
/// </summary>
|
|
protected void OnGUIParentChanged(RectTransform newParent)
|
|
{
|
|
if (newParent == null)
|
|
{
|
|
// Make sure to unregister. It doesn't matter if we haven't ever registered to the event.
|
|
GameMain.Instance.ResolutionChanged -= OnResolutionChangedPrivate;
|
|
}
|
|
}
|
|
|
|
protected virtual void OnResolutionChanged() { }
|
|
|
|
private void OnResolutionChangedPrivate()
|
|
{
|
|
if (RecreateGUIOnResolutionChange)
|
|
{
|
|
ReloadGuiFrame();
|
|
CreateGUI();
|
|
}
|
|
OnResolutionChanged();
|
|
item.ForceHUDLayoutUpdate(ignoreLocking: true);
|
|
if (GuiFrame != null && GuiFrame.GetChild<GUIDragHandle>() is GUIDragHandle dragHandle)
|
|
{
|
|
dragHandle.DragArea = HUDLayoutSettings.ItemHUDArea;
|
|
}
|
|
}
|
|
|
|
public virtual void OnPlayerSkillsChanged() { }
|
|
|
|
public virtual void AddTooltipInfo(ref LocalizedString name, ref LocalizedString description) { }
|
|
}
|
|
}
|