1111 lines
46 KiB
C#
1111 lines
46 KiB
C#
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using GameCult.Aetheria.EveRuntime;
|
|
using GameCult.Aetheria.State.Verse;
|
|
using GameCult.Eve.Surface;
|
|
using TMPro;
|
|
using UniRx;
|
|
using UniRx.Triggers;
|
|
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
using UnityEngine.EventSystems;
|
|
using UnityEngine.Experimental.Rendering;
|
|
using Unity.Mathematics;
|
|
using UnityEngine.Serialization;
|
|
using UIE = UnityEngine.UIElements;
|
|
using static Unity.Mathematics.math;
|
|
using int2 = Unity.Mathematics.int2;
|
|
|
|
public class InventoryPanel : MonoBehaviour, IPointerClickHandler
|
|
{
|
|
public ConfirmationDialog Dialog;
|
|
public RectTransform DragParent;
|
|
public bool Flip;
|
|
public GameSettings Settings;
|
|
public ActionGameManager GameManager;
|
|
public TextMeshProUGUI Title;
|
|
public TextMeshProUGUI MinTempLabel;
|
|
public TextMeshProUGUI MaxTempLabel;
|
|
public GameObject TemperatureRange;
|
|
public Button Dropdown;
|
|
public Button EditName;
|
|
public Button Current;
|
|
public Button Thermal;
|
|
public GridLayoutGroup Grid;
|
|
public Sprite[] NodeBackgroundTextures;
|
|
public Sprite[] NodeTextures;
|
|
public Sprite[] ThermalTextures;
|
|
public float ThermalToggleRegionSize = .2f;
|
|
public Prototype NodePrototype;
|
|
public RawImage TemperatureDisplay;
|
|
public Texture2D TemperatureColor;
|
|
public ExponentialLerp TemperatureColorCurve;
|
|
public ExponentialLerp TemperatureAlphaCurve;
|
|
public bool FitToContent;
|
|
public float CellHitPulseTime;
|
|
public Color ToggleEnabledColor;
|
|
public Color ToggleDisabledColor;
|
|
public Color CellBackgroundColor = new Color(0, 0, 0, .75f);
|
|
public float MinTempRange = 1;
|
|
public float DoubleClickTime = .5f;
|
|
public float HitDamageThreshold = 1;
|
|
|
|
// Subject<InventoryEventData> _onBeginDrag;
|
|
// Subject<InventoryEventData> _onDrag;
|
|
// Subject<InventoryEventData> _onEndDrag;
|
|
Subject<(InventoryEventData data, int clickCount)> _onClick;
|
|
// Subject<InventoryEventData> _onPointerEnter;
|
|
// Subject<InventoryEventData> _onPointerExit;
|
|
|
|
private Entity _displayedEntity;
|
|
private EquippedCargoBay _displayedCargo;
|
|
private Shape _displayedHullShape;
|
|
private Shape _displayedHullInterior;
|
|
private Texture2D _temperatureTexture;
|
|
private RectTransform _firstRect;
|
|
|
|
public ItemInstance FakeItem;
|
|
public Shape FakeOccupancy;
|
|
public Shape IgnoreOccupancy;
|
|
public List<GameObject> EmptyCells = new List<GameObject>();
|
|
public Dictionary<int2, InventoryCell> CellInstances = new Dictionary<int2, InventoryCell>();
|
|
|
|
private List<IDisposable> _subscriptions = new List<IDisposable>();
|
|
private Dictionary<int2, int> _cellAnimationSequence = new Dictionary<int2, int>();
|
|
private int _hitSequence = 0;
|
|
private bool _thermal = false;
|
|
private int _clickCount;
|
|
private InventoryCell _clickCell;
|
|
private float _clickTime;
|
|
private AetheriaRuntimeInventoryDropdownSurfaceProjection _dropdownSurfaceProjection;
|
|
private readonly AetheriaEveUnitySurfaceChrome _dropdownSurfaceChrome = new AetheriaEveUnitySurfaceChrome
|
|
{
|
|
RootAlignItems = UIE.Align.FlexStart,
|
|
RootJustifyContent = UIE.Justify.FlexStart,
|
|
RootPaddingTop = 0f,
|
|
Width = 420f,
|
|
MinWidth = 0f,
|
|
MaxWidth = 520f,
|
|
PaddingLeft = 18f,
|
|
PaddingRight = 18f,
|
|
PaddingTop = 18f,
|
|
PaddingBottom = 18f
|
|
};
|
|
private UIE.UIDocument _dropdownSurfaceDocument;
|
|
|
|
private bool _hud;
|
|
|
|
private int2[] _offsets = {
|
|
int2(0, 1),
|
|
int2(1, 0),
|
|
int2(0, -1),
|
|
int2(-1, 0),
|
|
int2(1, 1),
|
|
int2(1, -1),
|
|
int2(-1, -1),
|
|
int2(-1, 1)
|
|
};
|
|
|
|
public InventoryPanelTarget Target =>
|
|
_displayedEntity != null ? InventoryPanelTarget.Equipment :
|
|
_displayedCargo != null ? InventoryPanelTarget.Cargo : InventoryPanelTarget.None;
|
|
public Entity DisplayedEntity => _displayedEntity;
|
|
public EquippedCargoBay DisplayedCargo => _displayedCargo;
|
|
|
|
private void Start()
|
|
{
|
|
if (Thermal)
|
|
{
|
|
Thermal.onClick.AddListener(() =>
|
|
{
|
|
HideDropdownSurface();
|
|
Display(_displayedEntity, false, !_thermal);
|
|
});
|
|
}
|
|
|
|
if (Current)
|
|
{
|
|
Current.onClick.AddListener(() =>
|
|
{
|
|
HideDropdownSurface();
|
|
var isDisplayedCurrentEntity =
|
|
GameManager.TryGetObservedCurrentEntity(out var currentEntity) &&
|
|
_displayedEntity == currentEntity;
|
|
if (!isDisplayedCurrentEntity)
|
|
{
|
|
if(_displayedEntity is Ship ship)
|
|
{
|
|
GameManager.RequestDockedCurrentShip(ship);
|
|
}
|
|
else
|
|
{
|
|
Dialog.Clear();
|
|
Dialog.Title.text = "Can't select entity, you can only pilot a ship!";
|
|
Dialog.Show();
|
|
Dialog.MoveToCursor();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
if (EditName)
|
|
{
|
|
EditName.onClick.AddListener(() =>
|
|
{
|
|
HideDropdownSurface();
|
|
Dialog.Clear();
|
|
var entityName = _displayedEntity.Name;
|
|
Dialog.AddField("Name", () => entityName, s => entityName = s);
|
|
Dialog.Show(() =>
|
|
{
|
|
GameManager.RequestEntityName(_displayedEntity, entityName);
|
|
});
|
|
Dialog.MoveToCursor();
|
|
});
|
|
}
|
|
|
|
if(Dropdown)
|
|
{
|
|
Dropdown.onClick.AddListener(() =>
|
|
{
|
|
RenderDropdownSurface();
|
|
});
|
|
}
|
|
}
|
|
|
|
private void RenderDropdownSurface()
|
|
{
|
|
_dropdownSurfaceProjection = ProjectDropdownSurface();
|
|
|
|
_dropdownSurfaceDocument = AetheriaEveUnitySurfaceHost.RenderRuntime(
|
|
transform,
|
|
_dropdownSurfaceDocument,
|
|
"Aetheria Inventory Dropdown Surface",
|
|
AetheriaRuntimeInventoryDropdownSurfaceBuilder.Build(_dropdownSurfaceProjection.State),
|
|
HandleDropdownSurfaceCommand,
|
|
_dropdownSurfaceChrome);
|
|
}
|
|
|
|
private void HandleDropdownSurfaceCommand(EveSurfaceCommandRequest request)
|
|
{
|
|
if (!AetheriaRuntimeInventoryDropdownSurfaceCommands.TryRead(request, out var command))
|
|
{
|
|
Debug.LogWarning($"Unknown inventory dropdown command: {request?.Command}");
|
|
return;
|
|
}
|
|
|
|
if (command.Kind == AetheriaRuntimeInventoryDropdownCommandKind.Close)
|
|
{
|
|
HideDropdownSurface();
|
|
return;
|
|
}
|
|
|
|
if (command.Kind == AetheriaRuntimeInventoryDropdownCommandKind.Select &&
|
|
_dropdownSurfaceProjection?.TryResolve(command.Command, out var selection) == true)
|
|
{
|
|
ExecuteDropdownSelection(selection);
|
|
HideDropdownSurface();
|
|
return;
|
|
}
|
|
|
|
Debug.LogWarning($"Unknown inventory dropdown command: {request?.Command}");
|
|
}
|
|
|
|
private void ExecuteDropdownSelection(AetheriaRuntimeInventoryDropdownSelection selection)
|
|
{
|
|
var entities = GameManager.ObservedAvailableEntities().ToArray();
|
|
var loadouts = GameManager.ObservedLoadoutTemplates().ToArray();
|
|
|
|
switch (selection.Kind)
|
|
{
|
|
case AetheriaRuntimeInventoryDropdownSelectionKind.EntityEquipment:
|
|
case AetheriaRuntimeInventoryDropdownSelectionKind.Entity:
|
|
if (selection.EntityIndex >= 0 && selection.EntityIndex < entities.Length)
|
|
{
|
|
Display(entities[selection.EntityIndex]);
|
|
}
|
|
return;
|
|
case AetheriaRuntimeInventoryDropdownSelectionKind.EntityBay:
|
|
if (selection.EntityIndex >= 0 &&
|
|
selection.EntityIndex < entities.Length &&
|
|
selection.BayIndex >= 0 &&
|
|
selection.BayIndex < entities[selection.EntityIndex].CargoBays.Count)
|
|
{
|
|
Display(entities[selection.EntityIndex].CargoBays[selection.BayIndex]);
|
|
}
|
|
return;
|
|
case AetheriaRuntimeInventoryDropdownSelectionKind.DockingBay:
|
|
if (GameManager.TryGetObservedDockingBay(out var dockingBay))
|
|
{
|
|
Display(dockingBay);
|
|
}
|
|
return;
|
|
case AetheriaRuntimeInventoryDropdownSelectionKind.SaveLoadout:
|
|
if (_displayedEntity != null)
|
|
{
|
|
GameManager.RequestLoadoutTemplateSave(_displayedEntity);
|
|
}
|
|
return;
|
|
case AetheriaRuntimeInventoryDropdownSelectionKind.Loadout:
|
|
if (selection.TemplateIndex >= 0 && selection.TemplateIndex < loadouts.Length)
|
|
{
|
|
GameManager.RequestRuntimeLoadoutRestore(loadouts[selection.TemplateIndex]);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void HideDropdownSurface()
|
|
{
|
|
if (_dropdownSurfaceDocument == null)
|
|
return;
|
|
|
|
AetheriaEveUnitySurfaceHost.Hide(_dropdownSurfaceDocument);
|
|
}
|
|
|
|
private AetheriaRuntimeInventoryDropdownSurfaceProjection ProjectDropdownSurface()
|
|
{
|
|
var entities = GameManager.ObservedAvailableEntities().ToArray();
|
|
var loadouts = GameManager.ObservedLoadoutTemplates().ToArray();
|
|
var entityOptions = entities
|
|
.Select((entity, entityIndex) => new AetheriaRuntimeInventoryDropdownEntityOption(
|
|
entityIndex,
|
|
entity.Name,
|
|
entity == _displayedEntity,
|
|
entity.CargoBays
|
|
.Select((bay, bayIndex) => new AetheriaRuntimeInventoryDropdownBayOption(
|
|
bayIndex,
|
|
$"Bay {bayIndex + 1}",
|
|
bay == _displayedCargo))
|
|
.ToArray()))
|
|
.ToArray();
|
|
var loadoutOptions = loadouts
|
|
.Select((template, templateIndex) =>
|
|
{
|
|
var canRestore =
|
|
GameManager.CreateEntityConstructionBlueprint(template) != null &&
|
|
AetheriaRuntimeDaemonTradeItemQueries.TryProjectLoadoutTemplatePrice(
|
|
template,
|
|
ActionGameManager.RuntimeCatalog,
|
|
GameManager.ObservedTradeValueSettings(),
|
|
out var price);
|
|
return new AetheriaRuntimeInventoryDropdownLoadoutOption(
|
|
templateIndex,
|
|
template.Name,
|
|
canRestore ? $"{price:n0}" : "",
|
|
canRestore);
|
|
})
|
|
.ToArray();
|
|
var hasDockingBay = GameManager.TryGetObservedDockingBay(out var dockingBay);
|
|
|
|
return AetheriaRuntimeInventoryDropdownSurfaceBuilder.Project(
|
|
Title?.text ?? "None",
|
|
entityOptions,
|
|
hasDockingBay,
|
|
hasDockingBay ? dockingBay.Name : "",
|
|
hasDockingBay && dockingBay == _displayedCargo,
|
|
_displayedEntity != null,
|
|
loadoutOptions,
|
|
DateTime.UtcNow.ToString("O"));
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
if (_displayedEntity != null && TemperatureDisplay)
|
|
{
|
|
var tempRange = _displayedEntity.MaxTemp - _displayedEntity.MinTemp;
|
|
var opacity = smoothstep(0, MinTempRange, tempRange);
|
|
if(MinTempLabel)
|
|
{
|
|
MinTempLabel.text = ActionGameManager.RuntimePlayerSettings.FormatTemperature(_displayedEntity.MinTemp);
|
|
MaxTempLabel.text = ActionGameManager.RuntimePlayerSettings.FormatTemperature(_displayedEntity.MaxTemp);
|
|
}
|
|
for(var x = 0; x < _temperatureTexture.width; x++)
|
|
{
|
|
for (var y = 0; y < _temperatureTexture.height; y++)
|
|
{
|
|
if (_displayedHullShape[int2(x-1, y-1)])
|
|
{
|
|
var temp = (_displayedEntity.Temperature[x - 1, y - 1] - _displayedEntity.MinTemp) / (_displayedEntity.MaxTemp-_displayedEntity.MinTemp);
|
|
var color = TemperatureColor.GetPixelBilinear(TemperatureColorCurve.Evaluate(temp), 0);
|
|
color.a = TemperatureAlphaCurve.Evaluate(temp) * opacity;
|
|
_temperatureTexture.SetPixel(x,y,color);
|
|
}
|
|
else
|
|
_temperatureTexture.SetPixel(x,y,new Color(0,0,0,0));
|
|
}
|
|
}
|
|
_temperatureTexture.Apply();
|
|
TemperatureDisplay.rectTransform.anchoredPosition = _firstRect.anchoredPosition - Vector2.one * Grid.cellSize * 1.5f;
|
|
}
|
|
}
|
|
|
|
private void OnDisable()
|
|
{
|
|
HideDropdownSurface();
|
|
Clear();
|
|
}
|
|
|
|
|
|
public void Clear()
|
|
{
|
|
HideDropdownSurface();
|
|
_displayedCargo = null;
|
|
_displayedEntity = null;
|
|
_displayedHullShape = null;
|
|
_displayedHullInterior = null;
|
|
|
|
foreach(var empty in EmptyCells)
|
|
Destroy(empty);
|
|
EmptyCells.Clear();
|
|
|
|
foreach(var node in CellInstances.Values)
|
|
node.GetComponent<Prototype>().ReturnToPool();
|
|
CellInstances.Clear();
|
|
|
|
foreach(var s in _subscriptions)
|
|
s.Dispose();
|
|
|
|
_subscriptions.Clear();
|
|
|
|
if (Current) Current.gameObject.SetActive(false);
|
|
if (Thermal) Thermal.gameObject.SetActive(false);
|
|
if (TemperatureRange) TemperatureRange.SetActive(false);
|
|
if(TemperatureDisplay) TemperatureDisplay.gameObject.SetActive(false);
|
|
if (EditName) EditName.gameObject.SetActive(false);
|
|
|
|
if(Title)
|
|
Title.text = "None";
|
|
}
|
|
|
|
public void Display(Entity entity, bool hud = false, bool thermal = false)
|
|
{
|
|
Clear();
|
|
|
|
_subscriptions.Add(entity.Equipment.ObserveAdd().Subscribe(_ => RefreshCells()));
|
|
_subscriptions.Add(entity.Equipment.ObserveRemove().Subscribe(_ => RefreshCells()));
|
|
|
|
_thermal = thermal;
|
|
_hud = hud;
|
|
|
|
_displayedEntity = entity;
|
|
_displayedCargo = null;
|
|
_firstRect = null;
|
|
|
|
if (TemperatureRange)
|
|
TemperatureRange.SetActive(true);
|
|
|
|
if(Title)
|
|
Title.text = entity.Name;
|
|
|
|
if (EditName)
|
|
{
|
|
EditName.gameObject.SetActive(true);
|
|
}
|
|
|
|
if (!TryResolveTypedHullGeometry(entity.Hull, out _displayedHullShape, out _displayedHullInterior))
|
|
{
|
|
Debug.LogError($"Cannot display inventory for {entity.Name}: missing typed hull geometry.");
|
|
return;
|
|
}
|
|
|
|
if (FitToContent)
|
|
{
|
|
var gridRect = Grid.GetComponent<RectTransform>();
|
|
var rect = gridRect.rect;
|
|
Grid.cellSize = Vector2.one * (int) min(rect.width / (_displayedHullShape.Width + 1), rect.height / (_displayedHullShape.Height + 1));
|
|
}
|
|
|
|
if(TemperatureDisplay)
|
|
{
|
|
_temperatureTexture = new Texture2D(
|
|
_displayedHullShape.Width + 2,
|
|
_displayedHullShape.Height + 2,
|
|
TextureFormat.RGBA32,
|
|
false,
|
|
false);
|
|
TemperatureDisplay.gameObject.SetActive(true);
|
|
TemperatureDisplay.texture = _temperatureTexture;
|
|
var tempRect = TemperatureDisplay.rectTransform;
|
|
tempRect.sizeDelta = Grid.cellSize * new Vector2(_displayedHullShape.Width + 2, _displayedHullShape.Height + 2);
|
|
}
|
|
|
|
if (Current)
|
|
{
|
|
Current.gameObject.SetActive(true);
|
|
Current.targetGraphic.color =
|
|
GameManager.TryGetObservedCurrentEntity(out var currentEntity) && entity == currentEntity
|
|
? ToggleEnabledColor
|
|
: ToggleDisabledColor;
|
|
}
|
|
if (Thermal)
|
|
{
|
|
Thermal.gameObject.SetActive(true);
|
|
Thermal.targetGraphic.color = thermal ? ToggleEnabledColor : ToggleDisabledColor;
|
|
}
|
|
|
|
Grid.constraintCount = _displayedHullShape.Width;
|
|
foreach (var v in _displayedHullShape.AllCoordinates)
|
|
{
|
|
if (!_displayedHullShape[v])
|
|
{
|
|
var empty = new GameObject("Empty Node", typeof(RectTransform));
|
|
empty.transform.SetParent(Grid.transform);
|
|
if (!_firstRect)
|
|
_firstRect = empty.GetComponent<RectTransform>();
|
|
EmptyCells.Add(empty);
|
|
}
|
|
else
|
|
{
|
|
var cell = NodePrototype.Instantiate<InventoryCell>();
|
|
cell.Background.color = CellBackgroundColor;
|
|
if (!_firstRect)
|
|
_firstRect = cell.GetComponent<RectTransform>();
|
|
if (!thermal)
|
|
{
|
|
if(cell.PointerClickTrigger)
|
|
{
|
|
cell.PointerClickTrigger.OnPointerClickAsObservable()
|
|
.Subscribe(data =>
|
|
{
|
|
if (cell != _clickCell || Time.time - _clickTime > DoubleClickTime)
|
|
_clickCount = 0;
|
|
_clickCell = cell;
|
|
_clickTime = Time.time;
|
|
_clickCount++;
|
|
_onClick?.OnNext((new InventoryEntityEventData(data, v, entity), _clickCount));
|
|
});
|
|
cell.BeginDragTrigger.OnBeginDragAsObservable()
|
|
.Subscribe(data =>
|
|
{
|
|
//Debug.Log("Entity Drag Start");
|
|
var item = entity.GearOccupancy[v.x, v.y];
|
|
if (item != null)
|
|
{
|
|
var originalOccupancy = _displayedHullShape.Inset(GetItemShape(item.EquippableItem), item.Position, item.EquippableItem.Rotation);
|
|
_dragCells = originalOccupancy.Coordinates
|
|
.Select(v1 => Instantiate(CellInstances[v1], DragParent, true).transform).ToArray();
|
|
foreach(var dragCell in _dragCells)
|
|
{
|
|
DestroyImmediate(dragCell.GetComponent<Prototype>());
|
|
foreach (var component in dragCell.GetComponentsInChildren<ObservableTriggerBase>())
|
|
component.enabled = false;
|
|
foreach (var img in dragCell.GetComponentsInChildren<Image>())
|
|
img.color = new Color(img.color.r, img.color.g, img.color.b, img.color.a * .5f);
|
|
dragCell.GetComponentInChildren<Image>().raycastTarget = false;
|
|
}
|
|
_dragOffsets = _dragCells.Select(x => (Vector2) x.position - data.position).ToArray();
|
|
IgnoreOccupancy = originalOccupancy;
|
|
RefreshCells();
|
|
_originalRotation = item.EquippableItem.Rotation;
|
|
GameManager.BeginDrag(new EquippedItemDragObject(item, entity, item.Position - v));
|
|
//AkSoundEngine.PostEvent("Pickup", gameObject);
|
|
// TODO: SFX: Pickup Item
|
|
}
|
|
});
|
|
cell.DragTrigger.OnDragAsObservable()
|
|
.Subscribe(data =>
|
|
{
|
|
for (var i = 0; i < _dragCells.Length; i++)
|
|
_dragCells[i].position = new Vector3(
|
|
data.position.x + _dragOffsets[i].x,
|
|
data.position.y + _dragOffsets[i].y,
|
|
_dragCells[i].position.z);
|
|
});
|
|
cell.EndDragTrigger.OnEndDragAsObservable()
|
|
.Subscribe(data =>
|
|
{
|
|
//Debug.Log("Entity Drag End");
|
|
IgnoreOccupancy = null;
|
|
var hadDragTarget = GameManager.HasDragTarget;
|
|
GameManager.EndDrag();
|
|
if (!hadDragTarget)
|
|
entity.GearOccupancy[v.x, v.y].EquippableItem.Rotation = _originalRotation;
|
|
foreach(var dragObject in _dragCells)
|
|
Destroy(dragObject.gameObject);
|
|
_dragCells = null;
|
|
RefreshCells();
|
|
});
|
|
cell.PointerEnterTrigger.OnPointerEnterAsObservable()
|
|
.Subscribe(data =>
|
|
{
|
|
//Debug.Log("Entity Pointer Enter");
|
|
if (!(GameManager.DragObject is ItemDragObject itemDragObject)) return;
|
|
var item = itemDragObject.Item;
|
|
if (!(item is EquippableItem equippableItem)) return;
|
|
var placementPosition = v + itemDragObject.OriginCellOffset;
|
|
//foreach (var cell in _dragCells) cell.gameObject.SetActive(false);
|
|
FakeItem = item;
|
|
FakeOccupancy = _displayedHullShape.Inset(GetItemShape(equippableItem), placementPosition, item.Rotation);
|
|
RefreshCells();
|
|
GameManager.RegisterDragTarget(drag =>
|
|
{
|
|
//Debug.Log("Entity Drag Callback");
|
|
FakeOccupancy = null;
|
|
RequestDraggedItemToEntity(drag, entity, placementPosition);
|
|
// TODO: SFX: Equip
|
|
});
|
|
});
|
|
cell.PointerExitTrigger.OnPointerExitAsObservable()
|
|
.Subscribe(data =>
|
|
{
|
|
if (!(GameManager.DragObject is ItemDragObject)) return;
|
|
FakeItem = null;
|
|
FakeOccupancy = null;
|
|
RefreshCells();
|
|
GameManager.UnregisterDragTarget();
|
|
});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cell.PointerClickTrigger.OnPointerClickAsObservable().Subscribe(data =>
|
|
{
|
|
var rect = cell.GetComponent<RectTransform>();
|
|
var point = Rect.PointToNormalized(rect.rect, rect.InverseTransformPoint(data.position));
|
|
// Debug.Log($"Clicked at pos {data.position}, normalized {point}");
|
|
if (_displayedHullShape[int2(v.x - 1, v.y)] && point.x < ThermalToggleRegionSize)
|
|
{
|
|
GameManager.RequestHullConductivityToggle(entity, int2(v.x - 1, v.y), 0);
|
|
}
|
|
if (_displayedHullShape[int2(v.x + 1, v.y)] && point.x > 1 - ThermalToggleRegionSize)
|
|
{
|
|
GameManager.RequestHullConductivityToggle(entity, int2(v.x, v.y), 0);
|
|
}
|
|
if (_displayedHullShape[int2(v.x, v.y - 1)] && point.y < ThermalToggleRegionSize)
|
|
{
|
|
GameManager.RequestHullConductivityToggle(entity, int2(v.x, v.y - 1), 1);
|
|
}
|
|
if (_displayedHullShape[int2(v.x, v.y + 1)] && point.y > 1 - ThermalToggleRegionSize)
|
|
{
|
|
GameManager.RequestHullConductivityToggle(entity, int2(v.x, v.y), 1);
|
|
}
|
|
});
|
|
}
|
|
CellInstances.Add(v, cell);
|
|
}
|
|
}
|
|
RefreshCells(CellInstances.Keys);
|
|
|
|
_subscriptions.Add(entity.ArmorDamage.Subscribe(hit =>
|
|
{
|
|
var hitCells = new[] { hit.pos };
|
|
StartCoroutine(Pulse(hitCells, HitType.Armor, _hitSequence++));
|
|
RefreshCells(hitCells);
|
|
}));
|
|
|
|
_subscriptions.Add(entity.ItemDamage.Where(hit=>hit.damage > HitDamageThreshold).Subscribe(hit =>
|
|
{
|
|
var hitCells = hit.item.InsetShape.Coordinates;
|
|
if(gameObject.activeInHierarchy)
|
|
StartCoroutine(Pulse(hitCells, HitType.Armor, _hitSequence++));
|
|
RefreshCells(hitCells);
|
|
}));
|
|
}
|
|
|
|
private IEnumerator Pulse(int2[] cells, HitType hitType, int sequence)
|
|
{
|
|
foreach (var cell in cells)
|
|
{
|
|
if(_cellAnimationSequence.ContainsKey(cell))
|
|
_cellAnimationSequence[cell] = max(_cellAnimationSequence[cell], sequence);
|
|
else
|
|
_cellAnimationSequence[cell] = sequence;
|
|
}
|
|
var hitColor = hitType switch
|
|
{
|
|
HitType.Armor => Settings.ArmorHitColor,
|
|
HitType.Hardpoint => Settings.HardpointHitColor,
|
|
HitType.Gear => Settings.GearHitColor,
|
|
_ => Color.white
|
|
};
|
|
float startTime = Time.time;
|
|
while (Time.time - startTime < CellHitPulseTime)
|
|
{
|
|
var lerp = (Time.time - startTime) / CellHitPulseTime;
|
|
foreach(var cell in cells)
|
|
if(_cellAnimationSequence[cell] == sequence)
|
|
if(CellInstances.ContainsKey(cell))
|
|
CellInstances[cell].Background.color = Color.Lerp(hitColor, CellBackgroundColor, lerp);
|
|
yield return null;
|
|
}
|
|
foreach (var cell in cells)
|
|
if(CellInstances.ContainsKey(cell))
|
|
CellInstances[cell].Background.color = CellBackgroundColor;
|
|
}
|
|
|
|
public void Display(EquippedCargoBay cargo)
|
|
{
|
|
Clear();
|
|
|
|
_subscriptions.Add(cargo.Cargo.ObserveAdd().Subscribe(_ => RefreshCells()));
|
|
_subscriptions.Add(cargo.Cargo.ObserveRemove().Subscribe(_ => RefreshCells()));
|
|
|
|
_displayedCargo = cargo;
|
|
_displayedEntity = null;
|
|
|
|
if(Title)
|
|
Title.text = cargo.Name;
|
|
|
|
// FakeOccupancy = new Shape(cargo.InteriorShape.Width, cargo.InteriorShape.Height);
|
|
// IgnoreOccupancy = new Shape(cargo.InteriorShape.Width, cargo.InteriorShape.Height);
|
|
Grid.constraintCount = cargo.InteriorShape.Width;
|
|
foreach (var v in cargo.InteriorShape.AllCoordinates)
|
|
{
|
|
if (!cargo.InteriorShape[v])
|
|
{
|
|
var empty = new GameObject("Empty Node", typeof(RectTransform));
|
|
empty.transform.SetParent(Grid.transform);
|
|
EmptyCells.Add(empty);
|
|
}
|
|
else
|
|
{
|
|
var cell = NodePrototype.Instantiate<InventoryCell>();
|
|
cell.PointerClickTrigger.OnPointerClickAsObservable()
|
|
.Subscribe(data =>
|
|
{
|
|
if (cell != _clickCell || Time.time - _clickTime > DoubleClickTime)
|
|
_clickCount = 0;
|
|
_clickCell = cell;
|
|
_clickTime = Time.time;
|
|
_clickCount++;
|
|
_onClick?.OnNext((new InventoryCargoEventData(data, v, cargo), _clickCount));
|
|
});
|
|
cell.BeginDragTrigger.OnBeginDragAsObservable()
|
|
.Subscribe(data =>
|
|
{
|
|
//Debug.Log("Inventory Drag Start");
|
|
var item = cargo.Occupancy[v.x, v.y];
|
|
if (item != null)
|
|
{
|
|
var itemPosition = cargo.Cargo[item];
|
|
var originalOccupancy = cargo.InteriorShape.Inset(GetItemShape(item), itemPosition, item.Rotation);
|
|
_dragCells = originalOccupancy.Coordinates
|
|
.Select(v1 => Instantiate(CellInstances[v1], DragParent, true).transform).ToArray();
|
|
foreach(var dragCell in _dragCells)
|
|
{
|
|
DestroyImmediate(dragCell.GetComponent<Prototype>());
|
|
foreach (var component in dragCell.GetComponentsInChildren<ObservableTriggerBase>())
|
|
component.enabled = false;
|
|
foreach (var img in dragCell.GetComponentsInChildren<Image>())
|
|
img.color = new Color(img.color.r, img.color.g, img.color.b, img.color.a * .5f);
|
|
dragCell.GetComponentInChildren<Image>().raycastTarget = false;
|
|
}
|
|
_dragOffsets = _dragCells.Select(x => (Vector2) x.position - data.position).ToArray();
|
|
IgnoreOccupancy = originalOccupancy;
|
|
RefreshCells();
|
|
_originalRotation = item.Rotation;
|
|
GameManager.BeginDrag(new ItemInstanceDragObject(item, cargo, cargo.Cargo[item] - v));
|
|
// TODO: SFX: Pickup
|
|
}
|
|
});
|
|
cell.DragTrigger.OnDragAsObservable()
|
|
.Subscribe(data =>
|
|
{
|
|
for (var i = 0; i < _dragCells.Length; i++)
|
|
_dragCells[i].position = new Vector3(
|
|
data.position.x + _dragOffsets[i].x,
|
|
data.position.y + _dragOffsets[i].y,
|
|
_dragCells[i].position.z);
|
|
});
|
|
cell.EndDragTrigger.OnEndDragAsObservable()
|
|
.Subscribe(data =>
|
|
{
|
|
//Debug.Log("Inventory Drag End");
|
|
IgnoreOccupancy = null;
|
|
GameManager.EndDrag();
|
|
foreach(var dragObject in _dragCells)
|
|
Destroy(dragObject.gameObject);
|
|
_dragCells = null;
|
|
RefreshCells();
|
|
});
|
|
cell.PointerEnterTrigger.OnPointerEnterAsObservable()
|
|
.Subscribe(data =>
|
|
{
|
|
//Debug.Log("Inventory Pointer Enter");
|
|
if (!(GameManager.DragObject is ItemDragObject itemDragObject)) return;
|
|
var item = itemDragObject.Item;
|
|
var placementPosition = v + itemDragObject.OriginCellOffset;
|
|
//foreach (var cell in _dragCells) cell.gameObject.SetActive(false);
|
|
FakeItem = item;
|
|
FakeOccupancy = cargo.InteriorShape.Inset(GetItemShape(item), placementPosition, item.Rotation);
|
|
RefreshCells();
|
|
GameManager.RegisterDragTarget(drag =>
|
|
{
|
|
//Debug.Log("Inventory Drag Callback");
|
|
FakeOccupancy = null;
|
|
RequestDraggedItemToCargo(drag, cargo, placementPosition);
|
|
// TODO: SFX: Drop
|
|
});
|
|
});
|
|
cell.PointerExitTrigger.OnPointerExitAsObservable()
|
|
.Subscribe(data =>
|
|
{
|
|
if (!(GameManager.DragObject is ItemDragObject)) return;
|
|
FakeItem = null;
|
|
FakeOccupancy = null;
|
|
RefreshCells();
|
|
GameManager.UnregisterDragTarget();
|
|
});
|
|
|
|
CellInstances.Add(v, cell);
|
|
}
|
|
}
|
|
RefreshCells();
|
|
}
|
|
|
|
public void RefreshCells()
|
|
{
|
|
RefreshCells(CellInstances.Keys);
|
|
}
|
|
|
|
public void RefreshCells(IEnumerable<int2> cells)
|
|
{
|
|
if (_displayedEntity != null)
|
|
{
|
|
foreach (var v in cells)
|
|
{
|
|
if(!CellInstances.ContainsKey(v)) continue;
|
|
|
|
var spriteIndex = 0;
|
|
var interior = _displayedHullInterior[v];
|
|
var item = FakeOccupancy?[v]??false ? FakeItem : IgnoreOccupancy?[v]??false ? null : _displayedEntity.GearOccupancy[v.x, v.y]?.EquippableItem;
|
|
var hardpoint = _displayedEntity.Hardpoints[v.x, v.y];
|
|
|
|
bool HardpointMatch(int2 offset)
|
|
{
|
|
var v2 = v + offset * (Flip ? -1 : 1);
|
|
return !(
|
|
_displayedHullShape[v2] &&
|
|
_displayedEntity.Hardpoints[v2.x, v2.y] == hardpoint &&
|
|
(FakeOccupancy?[v2]??false ? FakeItem : IgnoreOccupancy?[v2]??false ? null : _displayedEntity.GearOccupancy[v2.x, v2.y]?.EquippableItem) == item
|
|
);
|
|
}
|
|
|
|
bool NoHardpointMatch(int2 offset)
|
|
{
|
|
var v2 = v + offset * (Flip ? -1 : 1);
|
|
return !(
|
|
_displayedHullShape[v2] && (
|
|
!interior && !_displayedHullInterior[v2] && _displayedEntity.Hardpoints[v2.x, v2.y] == null ||
|
|
interior && item != null &&
|
|
(FakeOccupancy?[v2]??false ? FakeItem : IgnoreOccupancy?[v2]??false ? null : _displayedEntity.GearOccupancy[v2.x, v2.y]?.EquippableItem) == item
|
|
)
|
|
);
|
|
}
|
|
|
|
if (hardpoint != null)
|
|
{
|
|
for(int i = 0; i < 8; i++)
|
|
if (HardpointMatch(_offsets[i]))
|
|
spriteIndex += 1 << i;
|
|
}
|
|
else
|
|
{
|
|
for(int i = 0; i < 8; i++)
|
|
if (NoHardpointMatch(_offsets[i]))
|
|
spriteIndex += 1 << i;
|
|
}
|
|
|
|
var bgSpriteIndex = spriteIndex;
|
|
|
|
if (item != null)
|
|
spriteIndex += 1 << 8;
|
|
|
|
if (_thermal)
|
|
{
|
|
bool ThermalMatch(int2 offset)
|
|
{
|
|
if (!_displayedHullShape[v + offset]) return false;
|
|
var i = (offset.x, offset.y);
|
|
return i switch
|
|
{
|
|
(1, 0) => _displayedEntity.HullConductivity[v.x, v.y].x,
|
|
(-1, 0) => _displayedEntity.HullConductivity[v.x-1, v.y].x,
|
|
(0, 1) => _displayedEntity.HullConductivity[v.x, v.y].y,
|
|
(0, -1) => _displayedEntity.HullConductivity[v.x, v.y-1].y,
|
|
_ => false
|
|
};
|
|
}
|
|
spriteIndex = 0;
|
|
for(int i = 0; i < 4; i++)
|
|
if (ThermalMatch(_offsets[i]))
|
|
spriteIndex += 1 << i;
|
|
}
|
|
|
|
CellInstances[v].Background.sprite = NodeBackgroundTextures[bgSpriteIndex];
|
|
CellInstances[v].Icon.sprite = _thermal ? ThermalTextures[spriteIndex] : NodeTextures[spriteIndex];
|
|
CellInstances[v].Icon.color = GetColor(v);
|
|
}
|
|
}
|
|
else if(_displayedCargo != null)
|
|
{
|
|
foreach (var v in cells)
|
|
{
|
|
if(!CellInstances.ContainsKey(v)) continue;
|
|
|
|
var spriteIndex = 0;
|
|
var item = FakeOccupancy?[v]??false ? FakeItem : IgnoreOccupancy?[v]??false ? null : _displayedCargo.Occupancy[v.x, v.y];
|
|
|
|
bool ItemMatch(int2 offset)
|
|
{
|
|
var v2 = v + offset;
|
|
return !_displayedCargo.InteriorShape[v2] || item == null ||
|
|
(FakeOccupancy?[v2]??false ? FakeItem : IgnoreOccupancy?[v2]??false ? null : _displayedCargo.Occupancy[v2.x, v2.y]) != item;
|
|
}
|
|
|
|
for(int i = 0; i < 8; i++)
|
|
if (ItemMatch(_offsets[i]))
|
|
spriteIndex += 1 << i;
|
|
|
|
var bgSpriteIndex = spriteIndex;
|
|
|
|
if (item != null)
|
|
spriteIndex += 1 << 8;
|
|
|
|
CellInstances[v].Background.sprite = NodeBackgroundTextures[bgSpriteIndex];
|
|
CellInstances[v].Icon.sprite = NodeTextures[spriteIndex];
|
|
CellInstances[v].Icon.color = GetColor(v);
|
|
}
|
|
}
|
|
}
|
|
|
|
public Color GetColor(int2 position, bool highlight = false)
|
|
{
|
|
if (_displayedEntity != null)
|
|
{
|
|
var interior = _displayedHullInterior[position];
|
|
var hardpoint = _displayedEntity.Hardpoints[position.x, position.y];
|
|
var item = (FakeOccupancy?[position] ?? false ? FakeItem :
|
|
IgnoreOccupancy?[position] ?? false ? null : _displayedEntity.GearOccupancy[position.x, position.y]?.EquippableItem) as EquippableItem;
|
|
|
|
if (_hud)
|
|
{
|
|
if (_displayedEntity.Armor[position.x, position.y] > .01f)
|
|
return Settings.ArmorGradient.Evaluate(_displayedEntity.Armor[position.x, position.y] / _displayedEntity.MaxArmor[position.x, position.y]);
|
|
|
|
if (item != null) return Settings.DurabilityGradient.Evaluate(item.Durability / GetMaxDurability(item));
|
|
return float3(.25f).ToColor();
|
|
}
|
|
|
|
if (hardpoint == null)
|
|
{
|
|
if(!interior)
|
|
return Color.white;
|
|
|
|
if (item == null)
|
|
{
|
|
return float3(.25f).ToColor();
|
|
}
|
|
|
|
if(highlight)
|
|
return Color.white;
|
|
|
|
return float3(.5f).ToColor();
|
|
}
|
|
|
|
var tint = hardpoint.TintColor;
|
|
|
|
if (!highlight || item == null)
|
|
tint *= .7071f;
|
|
|
|
return tint.ToColor();
|
|
}
|
|
else
|
|
{
|
|
var item = FakeOccupancy?[position] ?? false ? FakeItem : IgnoreOccupancy?[position] ?? false ? null : _displayedCargo.Occupancy[position.x, position.y];
|
|
|
|
if (item == null)
|
|
return Color.white * .25f;
|
|
|
|
var c = float3(1);
|
|
if (TryGetTypedHardpointType(item, out var typedHardpoint))
|
|
c = HardpointData.GetColor(typedHardpoint).ToUnityFloat3();
|
|
|
|
if(!highlight)
|
|
c *= .7071f;
|
|
|
|
return c.ToColor();
|
|
}
|
|
}
|
|
|
|
private static bool TryGetTypedHardpointType(ItemInstance item, out HardpointType hardpointType)
|
|
{
|
|
hardpointType = HardpointType.Hull;
|
|
var typedItem = FindTypedInventoryItem(item);
|
|
return typedItem != null &&
|
|
!string.IsNullOrWhiteSpace(typedItem.HardpointType) &&
|
|
Enum.TryParse(typedItem.HardpointType, true, out hardpointType);
|
|
}
|
|
|
|
private float GetMaxDurability(ItemInstance item)
|
|
{
|
|
var typedItem = FindTypedInventoryItem(item);
|
|
if (typedItem != null && typedItem.Durability > 0)
|
|
return (float)typedItem.Durability;
|
|
|
|
return item is EquippableItem equippable ? Math.Max(equippable.Durability, 1f) : 1f;
|
|
}
|
|
|
|
private Shape GetItemShape(ItemInstance item)
|
|
{
|
|
var typedItem = FindTypedInventoryItem(item);
|
|
if (typedItem != null && typedItem.ShapeCells.Count > 0)
|
|
return ToShape(typedItem.ShapeWidth, typedItem.ShapeHeight, typedItem.ShapeCells);
|
|
|
|
return new Shape(1, 1);
|
|
}
|
|
|
|
private static bool TryResolveTypedHullGeometry(ItemInstance hull, out Shape hullShape, out Shape interiorShape)
|
|
{
|
|
hullShape = null;
|
|
interiorShape = null;
|
|
var typedHull = FindTypedInventoryItem(hull);
|
|
if (typedHull == null ||
|
|
typedHull.ShapeCells.Count == 0 ||
|
|
typedHull.InteriorShapeCells.Count == 0 ||
|
|
typedHull.ShapeWidth <= 0 ||
|
|
typedHull.ShapeHeight <= 0 ||
|
|
typedHull.InteriorShapeWidth <= 0 ||
|
|
typedHull.InteriorShapeHeight <= 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
hullShape = ToShape(typedHull.ShapeWidth, typedHull.ShapeHeight, typedHull.ShapeCells);
|
|
interiorShape = ToShape(typedHull.InteriorShapeWidth, typedHull.InteriorShapeHeight, typedHull.InteriorShapeCells);
|
|
return true;
|
|
}
|
|
|
|
private static Shape ToShape(int width, int height, IReadOnlyList<AetheriaRuntimeShapeCell> cells)
|
|
{
|
|
var shape = new Shape(Math.Max(width, 1), Math.Max(height, 1));
|
|
foreach (var cell in cells)
|
|
{
|
|
if (cell.X >= 0 && cell.Y >= 0 && cell.X < shape.Width && cell.Y < shape.Height)
|
|
shape[int2(cell.X, cell.Y)] = true;
|
|
}
|
|
|
|
return shape;
|
|
}
|
|
|
|
private static AetheriaRuntimeCatalogItem FindTypedInventoryItem(ItemInstance item)
|
|
{
|
|
return ActionGameManager.RuntimeCatalog?.FindItem(item?.ItemKey ?? "");
|
|
}
|
|
|
|
private void RequestDraggedItemToEntity(DragObject drag, Entity destination, int2 destinationPosition)
|
|
{
|
|
switch (drag)
|
|
{
|
|
case EquippedItemDragObject equippedItemDragObject:
|
|
GameManager.RequestEquippedItemEquip(
|
|
equippedItemDragObject.OriginEntity,
|
|
equippedItemDragObject.EquippedItem,
|
|
destination,
|
|
destinationPosition);
|
|
return;
|
|
case ItemInstanceDragObject itemInstanceDragObject when itemInstanceDragObject.Item is EquippableItem equippableItem:
|
|
GameManager.RequestCargoItemEquip(
|
|
itemInstanceDragObject.OriginInventory,
|
|
destination,
|
|
equippableItem,
|
|
destinationPosition);
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void RequestDraggedItemToCargo(DragObject drag, EquippedCargoBay destination, int2 destinationPosition)
|
|
{
|
|
switch (drag)
|
|
{
|
|
case EquippedItemDragObject equippedItemDragObject:
|
|
GameManager.RequestEquippedItemStore(
|
|
equippedItemDragObject.OriginEntity,
|
|
equippedItemDragObject.EquippedItem,
|
|
destination,
|
|
destinationPosition);
|
|
return;
|
|
case ItemInstanceDragObject itemInstanceDragObject:
|
|
GameManager.RequestCargoItemTransfer(
|
|
itemInstanceDragObject.OriginInventory,
|
|
destination,
|
|
itemInstanceDragObject.Item,
|
|
destinationPosition);
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
if (_dropdownSurfaceDocument != null)
|
|
{
|
|
AetheriaEveUnitySurfaceHost.DestroyDocument(_dropdownSurfaceDocument);
|
|
_dropdownSurfaceDocument = null;
|
|
}
|
|
}
|
|
|
|
public Subject<PointerEventData> OnBackgroundClick = new Subject<PointerEventData>();
|
|
private Transform[] _dragCells;
|
|
private Vector2[] _dragOffsets;
|
|
private ItemRotation _originalRotation;
|
|
|
|
public Subject<(InventoryEventData data, int clickCount)> OnClickAsObservable() => _onClick ?? (_onClick = new Subject<(InventoryEventData data, int clickCount)>());
|
|
// public UniRx.IObservable<InventoryEventData> OnBeginDragAsObservable() => _onBeginDrag ?? (_onBeginDrag = new Subject<InventoryEventData>());
|
|
// public UniRx.IObservable<InventoryEventData> OnDragAsObservable() => _onDrag ?? (_onDrag = new Subject<InventoryEventData>());
|
|
// public UniRx.IObservable<InventoryEventData> OnEndDragAsObservable() => _onEndDrag ?? (_onEndDrag = new Subject<InventoryEventData>());
|
|
// public UniRx.IObservable<InventoryEventData> OnPointerEnterAsObservable() => _onPointerEnter ?? (_onPointerEnter = new Subject<InventoryEventData>());
|
|
// public UniRx.IObservable<InventoryEventData> OnPointerExitAsObservable() => _onPointerExit ?? (_onPointerExit = new Subject<InventoryEventData>());
|
|
|
|
public void OnPointerClick(PointerEventData eventData)
|
|
{
|
|
OnBackgroundClick.OnNext(eventData);
|
|
}
|
|
}
|
|
|
|
public abstract class InventoryEventData
|
|
{
|
|
protected InventoryEventData(PointerEventData pointerEventData, int2 position)
|
|
{
|
|
PointerEventData = pointerEventData;
|
|
Position = position;
|
|
}
|
|
|
|
public PointerEventData PointerEventData { get; }
|
|
public int2 Position { get; }
|
|
}
|
|
|
|
public class InventoryEntityEventData : InventoryEventData
|
|
{
|
|
public InventoryEntityEventData(PointerEventData pointerEventData, int2 position, Entity entity) :
|
|
base(pointerEventData, position)
|
|
{
|
|
Entity = entity;
|
|
}
|
|
|
|
public Entity Entity { get; }
|
|
}
|
|
|
|
public class InventoryCargoEventData : InventoryEventData
|
|
{
|
|
public InventoryCargoEventData(PointerEventData pointerEventData, int2 position, EquippedCargoBay cargoBay) :
|
|
base(pointerEventData, position)
|
|
{
|
|
CargoBay = cargoBay;
|
|
}
|
|
|
|
public EquippedCargoBay CargoBay { get; }
|
|
}
|
|
|
|
public enum InventoryPanelTarget
|
|
{
|
|
None,
|
|
Cargo,
|
|
Equipment
|
|
}
|