protected void OnRaycastHit(List <GameObject> gameObjects)
{
for (int i = gameObjects.Count; i-- > 0;)
{
hit = gameObjects[i];
if (hit == null)
{
Debug.LogError("[Tooltip::OnRaycastHit] Encountered a null gameobject, probably shouldn't happen unless you're trying to tooltip a gameObject that's being destroyed.");
continue;
}
if (tooltips.TryGetValue(hit, out Tooltip t))
{
t.SetTooltipAsValid(); // Still a valid tooltip to keep.
UpdateTooltip(hit, t); // We already have the tooltip, so let's make sure it's updated.
continue;
}
data = hit.GetComponent <TooltipData>();
if (data)
{
tooltips.Add(hit, SpawnTooltip(hit, data.text, Input.mousePosition));
continue;
}
else if (!hit.transform.root.name.Contains("Canvas")) // if we're not looking at tooltip data, let's make sure it's not a UI element
{
OnRaycastEditorObject(hit);
}
}
ClearInvalidTooltips();
}
public void RaiseEvent(TooltipData data)
{
if (OnEventRaised != null)
{
OnEventRaised.Invoke(data);
}
}
static bool Prefix(TooltipData data, DescriptionBody body, bool isTooltip)
{
if (data.Buff != null)
{
var stored_spell_caption = data.Buff.Blueprint.GetComponent <AddStoredSpellToCaption>();
if (stored_spell_caption != null)
{
string spell_name = "";
data.Buff.CallComponents <AddStoredSpellToCaption>(c => c.getStoredSpellName(out spell_name));
if (!spell_name.Empty())
{
spell_name = $" ({spell_name})";
}
DescriptionBuilder.Templates.IconNameHeader(body.HeaderBox, data.Buff.Name + spell_name, data.Buff.Icon, isTooltip);
}
else
{
DescriptionBuilder.Templates.IconNameHeader(body.HeaderBox, data.Buff.Name, data.Buff.Icon, isTooltip);
}
if (isTooltip)
{
DescriptionBuilder.Templates.Timer(body.ContentBox, data.Buff);
}
DescriptionBuilder.Templates.ParagraphDescription(body.ContentBox, data.Buff.Description);
return(false);
}
else
{
return(true);
}
}
// private event Action _onTooltipClosed;
void Awake()
{
_currentTooltipData = null;
_closeButton.onClick.AddListener(Close);
_tooltipPageController.MaxPageReached.AddListener(() => _nextPageButtonObject.SetActive(false));
// _tooltipObject.SetActive(false);
}
public void SetTooltip(TooltipData tooltipData)
{
plusDamageSprite.enabled = false;
gameObject.SetActive(true);
title.text = tooltipData.Title;
description.text = tooltipData.Description;
sprite.enabled = true;
if (tooltipData.Sprite == null)
{
sprite.enabled = false;
}
else
{
sprite.sprite = tooltipData.Sprite;
sprite.preserveAspect = true;
}
if (tooltipData.Amount == 0)
{
moneyAmount.text = string.Empty;
}
else
{
moneyAmount.text = tooltipData.Amount.ToString();
}
if (tooltipData.PlusDamage == 0)
{
plusDamage.text = string.Empty;
}
else
{
plusDamage.text = tooltipData.PlusDamage.ToString();
plusDamageSprite.enabled = true;
}
}
static void updateRecipe(TechType techType, TooltipData data)
#endif
{
if (currentTreeType == CraftTree.Type.Constructor)
{
return;
}
if (techType != currentTechType)
{
reset();
}
if (currentTechType == TechType.None)
{
init(techType);
}
changeAmount(InputHelper.getMouseWheelDir());
#if GAME_SN
updateActionHint();
#elif GAME_BZ
string action = getActionText();
if (action != "")
{
data.postfix.AppendLine(action);
}
#endif
}
public void ShowTooltip(ITooltip tooltip)
{
if (!IsValidTooltip(tooltip))
{
return;
}
if (m_Tooltips.ContainsKey(tooltip))
{
return;
}
Material highlightMaterial = null;
var customToolTipColor = tooltip as ISetCustomTooltipColor;
if (customToolTipColor != null)
{
highlightMaterial = Instantiate(m_HighlightMaterial);
var customToolTipHighlightColor = customToolTipColor.customToolTipHighlightColor;
highlightMaterial.SetColor(k_MaterialColorTopProperty, customToolTipHighlightColor.a);
highlightMaterial.SetColor(k_MaterialColorBottomProperty, customToolTipHighlightColor.b);
}
m_Tooltips[tooltip] = new TooltipData
{
startTime = Time.realtimeSinceStartup,
customHighlightMaterial = highlightMaterial
};
}
public void mod_CopyButton(DescriptionBricksBox box, TooltipData data, bool isTooltip)
{
if (!KingmakerPatchSettings.UI.AddSpellbookNameToCopyScrollAction)
{
this.source_CopyButton(box, data, isTooltip);
return;
}
if (data.Item == null || data.Item.Blueprint.GetComponent <CopyItem>() == null)
{
return;
}
UnitEntityData unit = UIUtility.GetCurrentCharacter();
var component = data.Item.Blueprint.GetComponent <CopyItem>();
if (component == null || !component.CanCopy(data.Item, unit) || !Kingmaker.Game.Instance.Player.Inventory.Contains(data.Item.Blueprint) || isTooltip)
{
return;
}
DescriptionBrick descriptionBrick = box.Add(DescriptionTemplatesBase.Bricks.GreenButton);
string actionName = component.GetActionName(unit);
actionName = CopyScrollNew.mod_GetSpellbookActionName(actionName, data.Item, unit);
descriptionBrick.SetText(actionName);
descriptionBrick.SetButtonAction(() => Kingmaker.Game.Instance.UI.DescriptionController.CopyItem(data.Item, unit));
}
public TooltipData GetTooltip()
{
TooltipData tooltip = new TooltipData();
if (Item != null)
{
tooltip.show = true;
tooltip.title = Item.Name;
tooltip.content = Item.Description;
if (Item is Equipment equipment)
{
tooltip.content += "\n\nSlot: " + equipment.slot.ToString() + "\nCan wear: ";
for (int i = 0; i < equipment.Wearers.Length; i++)
{
tooltip.content += equipment.Wearers[i].name;
if (equipment.Wearers.Length > 1 && i != equipment.Wearers.Length - 1)
{
tooltip.content += ", ";
}
}
}
tooltip.image = Item.Image;
}
else
{
tooltip.show = false;
}
return(tooltip);
}
public void SetTooltip(TooltipData tooltipData)
{
gameObject.SetActive(true);
cooldownText.SetActive(false);
title.text = tooltipData.Title;
description.text = tooltipData.Description;
sprite.enabled = true;
if (tooltipData.Sprite == null)
{
sprite.enabled = false;
}
else
{
sprite.sprite = tooltipData.Sprite;
sprite.preserveAspect = true;
}
if (tooltipData.Amount == 0)
{
amount.text = string.Empty;
}
else
{
amount.text = tooltipData.Amount.ToString();
}
if (tooltipData.CooldownAmount == 0)
{
cooldownAmount.text = string.Empty;
}
else
{
cooldownText.SetActive(true);
cooldownAmount.text = tooltipData.CooldownAmount.ToString();
}
}
protected override void TriggerExitEvent()
{
TooltipData data = new TooltipData();
data.m_Switch = false;
m_Event.Trigger(data);
}
private void ProcessRequest(TooltipData tData)
{
if (tData.Active)
{
ChangeBlockState(true);
_tooltip.ProcessTooltip(tData);
}
}
public static void Postfix(bool locked, ref TooltipData data)
{
if (locked && GameModeUtils.RequiresBlueprints())
{
data.prefix.Clear();
TooltipFactory.WriteTitle(data.prefix, Main.Config.UnKnownTitle);
TooltipFactory.WriteDescription(data.prefix, Main.Config.UnKnownDescription);
}
}
void RecycleTooltip(TooltipData tooltipData)
{
var tooltipUI = tooltipData.tooltipUI;
tooltipUI.becameVisible -= tooltipData.becameVisible;
tooltipUI.gameObject.SetActive(false);
if (tooltipUI.removeSelf != null)
{
tooltipUI.removeSelf(tooltipUI);
}
m_TooltipPool.Enqueue(tooltipUI);
}
public void Display(TooltipData data)
{
if (data.icon != null)
{
m_Image.sprite = data.icon;
m_Image.gameObject.SetActive(true);
}
else
{
m_Image.gameObject.SetActive(false);
}
m_TextField.text = data.text;
m_WorldPosition = data.worldPosition;
StartAnimation(AnimationInOut(data.displayDuration, data.fadeDuration));
}
static void modifyTooltip(int index, TooltipData data)
#endif
{
if (!Main.config.showToolbarHotkeys)
{
return;
}
string text = $"<size=25><color=#ADF8FFFF>{index + 1}</color> - </size>";
#if GAME_SN
tooltipText = text + tooltipText;
#elif GAME_BZ
data.prefix.Insert(0, text);
#endif
}
public void Trigger(GameEventData eventData)
{
TooltipData data = eventData.CastDataType <TooltipData>();
if (data == null)
{
return;
}
if (data.m_Switch && !m_active)
{
Display(data.m_Message);
}
SetActive(data.m_Switch);
}
public void ShowTooltip(ITooltip tooltip)
{
if (string.IsNullOrEmpty(tooltip.tooltipText))
{
return;
}
if (m_Tooltips.ContainsKey(tooltip))
{
return;
}
m_Tooltips[tooltip] = new TooltipData
{
startTime = Time.realtimeSinceStartup
};
}
protected override void TriggerEnterEvent()
{
TooltipData data = new TooltipData();
if (m_text == null)
{
data.m_Message = m_Tooltip;
}
else
{
data.m_Message = m_text.ToString();
}
data.m_Switch = true;
m_Event.Trigger(data);
}
IEnumerator AnimateHide(ITooltip tooltip, TooltipData data)
{
var target = data.GetTooltipTarget(tooltip);
var startTime = Time.realtimeSinceStartup;
while (Time.realtimeSinceStartup - startTime < k_TransitionDuration)
{
if (!target)
{
break;
}
UpdateVisuals(tooltip, data, 1 - (Time.realtimeSinceStartup - startTime) / k_TransitionDuration);
yield return(null);
}
RecycleTooltip(data);
}
public void ProcessTooltip(TooltipData data)
{
if (_currentTooltipData == null)
{
_currentTooltipData = data;
_tooltipTextObject.text = data.TooltipText;
if (_tooltipTextObject.isTextOverflowing)
{
_nextPageButtonObject.SetActive(true);
}
else
{
_nextPageButtonObject.SetActive(false);
}
ShowTooltip();
}
}
private void ShowTooltip(TooltipData data)
{
// Try get action
InputAction action = MainSingleton.Instance.input.actions.FindAction(data.title);
string shortcut = null;
if (action != null)
{
shortcut = action.GetBindingDisplayString(DisplayStringOptions.DontIncludeInteractions, MainSingleton.Instance.input.currentControlScheme);
}
// Format
tooltipText.text =
$"<b>{data.title}</b>{(shortcut != null ? $"<align=\"flush\"> {shortcut.ToUpper()}</align>" : "")}" +
$"{(!string.IsNullOrEmpty(data.description) ? $"\n<size=80%>{data.description}" : "")}" +
$"{(!string.IsNullOrEmpty(data.footnote) ? $"\n<size=80%><i>{data.footnote}" : "")}";
canvasGroup.alpha = 1;
LayoutRebuilder.ForceRebuildLayoutImmediate((RectTransform)transform);
}
public void OnPointerEnter(PointerEventData eventData)
{
//Debug.Log("[Tooltip] Entered: " + eventData.pointerCurrentRaycast.gameObject.name);
if (tooltips.ContainsKey(eventData.pointerCurrentRaycast.gameObject))
{
return;
}
TooltipData data = eventData.pointerCurrentRaycast.gameObject.GetComponent <TooltipData>();
// we want to get actor component.
// then test the type of the stored actor
// then spawn the tooltip with the actor data.
if (data)
{// TODO: Have SpawnTooltip add the tooltip and gameobject to the dictionary instead.
tooltips.Add(eventData.pointerCurrentRaycast.gameObject,
SpawnTooltip(eventData.pointerCurrentRaycast.gameObject, data.text, eventData.position));
}
onPointerEnter?.Invoke(eventData);
}
void UpdateVisuals(ITooltip tooltip, TooltipData tooltipData, float lerp)
{
var target = tooltipData.GetTooltipTarget(tooltip);
var tooltipUI = tooltipData.tooltipUI;
var placement = tooltipData.placement;
var orientationWeight = tooltipData.orientationWeight;
var tooltipTransform = tooltipUI.transform;
lerp = MathUtilsExt.SmoothInOutLerpFloat(lerp); // shape the lerp for better presentation
var transitionLerp = MathUtilsExt.SmoothInOutLerpFloat(1.0f - Mathf.Clamp01((Time.time - tooltipData.transitionTime) / k_ChangeTransitionDuration));
var viewerScale = this.GetViewerScale();
tooltipTransform.localScale = m_TooltipScale * lerp * viewerScale;
// Adjust for alignment
var offset = GetTooltipOffset(tooltipUI, placement, tooltipData.transitionOffset * transitionLerp);
// The rectTransform expansion is handled in the Tooltip dynamically, based on alignment & text length
var rotationOffset = Quaternion.identity;
var camTransform = CameraUtils.GetMainCamera().transform;
if (Vector3.Dot(camTransform.forward, target.forward) < 0)
{
rotationOffset *= k_FlipYRotation;
}
if (Vector3.Dot(camTransform.up, target.up) + orientationWeight < 0)
{
rotationOffset *= k_FlipZRotation;
tooltipData.orientationWeight = -k_TextOrientationWeight;
}
else
{
tooltipData.orientationWeight = k_TextOrientationWeight;
}
MathUtilsExt.SetTransformOffset(target, tooltipTransform, offset * lerp, rotationOffset);
if (placement != null)
{
//TODO: Figure out why rect gives us different height/width than GetWorldCorners
tooltipUI.rectTransform.GetWorldCorners(k_Corners);
var bottomLeft = k_Corners[0];
var halfWidth = (bottomLeft - k_Corners[2]).magnitude * 0.5f;
var halfHeight = (bottomLeft - k_Corners[1]).magnitude * 0.5f;
var source = placement.tooltipSource;
var toSource = tooltipTransform.InverseTransformPoint(source.position);
// Position spheres: one at source, one on the closest edge of the tooltip
var spheres = tooltipUI.spheres;
spheres[0].position = source.position;
var attachedSphere = spheres[1];
var boxSlope = halfHeight / halfWidth;
var toSourceSlope = Mathf.Abs(toSource.y / toSource.x);
var parentScale = attachedSphere.parent.lossyScale;
halfHeight *= Mathf.Sign(toSource.y) / parentScale.x;
halfWidth *= Mathf.Sign(toSource.x) / parentScale.y;
attachedSphere.localPosition = toSourceSlope > boxSlope
? new Vector3(0, halfHeight)
: new Vector3(halfWidth, 0);
// Align dotted line
var attachedSpherePosition = attachedSphere.position;
toSource = source.position - attachedSpherePosition;
var midPoint = attachedSpherePosition + toSource * 0.5f;
var dottedLine = tooltipUI.dottedLine;
var length = toSource.magnitude;
var uvRect = dottedLine.uvRect;
var worldScale = 1 / viewerScale;
uvRect.width = length * k_UVScale * worldScale;
uvRect.xMin += k_UVScrollSpeed * Time.deltaTime;
dottedLine.uvRect = uvRect;
var dottedLineTransform = dottedLine.transform.parent.GetComponent <RectTransform>();
dottedLineTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, length / tooltipTransform.lossyScale.x);
dottedLineTransform.position = midPoint;
dottedLineTransform.rotation = Quaternion.LookRotation(toSource, -tooltipTransform.forward);
}
}
public void ShowTooltip(ITooltip tooltip, bool persistent = false, float duration = 0f, ITooltipPlacement placement = null, Action becameVisible = null)
{
if (!IsValidTooltip(tooltip))
{
return;
}
TooltipData data;
if (m_Tooltips.TryGetValue(tooltip, out data))
{
// Compare the targets to see if they changed
var currentTarget = data.GetTooltipTarget(tooltip);
var currentPlacement = data.placement;
data.persistent |= persistent;
data.placement = placement ?? tooltip as ITooltipPlacement;
// Set the text to new text
var tooltipUI = data.tooltipUI;
if (tooltipUI)
{
tooltipUI.Show(tooltip.tooltipText, data.placement.tooltipAlignment);
var newTarget = data.GetTooltipTarget(tooltip);
if (currentTarget != newTarget)
{
// Get the different between the 'old' tooltip position and 'new' tooltip position, even taking alignment into account
var transitionLerp = 1.0f - Mathf.Clamp01((Time.time - data.transitionTime) / k_ChangeTransitionDuration);
var currentPosition = currentTarget.TransformPoint(GetTooltipOffset(tooltipUI, currentPlacement, data.transitionOffset * transitionLerp));
var newPosition = newTarget.TransformPoint(GetTooltipOffset(tooltipUI, data.placement, Vector3.zero));
// Store it as an additional offset that we'll quickly lerp from
data.transitionOffset = newTarget.InverseTransformVector(currentPosition - newPosition);
data.transitionTime = Time.time;
}
if (duration > 0)
{
data.duration = duration;
data.lastModifiedTime = Time.time;
}
}
return;
}
// Negative durations only affect existing tooltips
if (duration < 0)
{
return;
}
m_Tooltips[tooltip] = new TooltipData
{
startTime = Time.time,
lastModifiedTime = Time.time,
persistent = persistent,
duration = duration,
becameVisible = becameVisible,
placement = placement ?? tooltip as ITooltipPlacement,
orientationWeight = 0.0f,
transitionOffset = Vector3.zero,
transitionTime = 0.0f,
};
}
private void ClosedNotify()
{
Closed.Invoke(_currentTooltipData);
_currentTooltipData = null;
}
static void Postfix(DescriptionTemplatesLevelup __instance, DescriptionBricksBox box, TooltipData data, bool b)
{
try
{
if (data?.Archetype == null)
{
return;
}
Prerequisites(__instance, box, data.Archetype.GetComponents <Prerequisite>(), data.ParentFeatureSelection);
}
catch (Exception e)
{
Log.Error(e);
}
}
public void GetTooltip(TooltipData tooltip)
{
tooltip.prefix.Append(Tooltip);
}
static void Postfix(DescriptionTemplatesLevelup __instance, DescriptionBricksBox box, TooltipData data, bool b)
{
try
{
if (data?.Archetype == null || Main.settings?.RelaxAncientLorekeeper == true)
{
return;
}
Prerequisites(__instance, box, data.Archetype.GetComponents <Prerequisite>());
}
catch (Exception e)
{
Log.Error(e);
}
}
private void TooltipClosed(TooltipData tData)
{
tData.Active = false;
ChangeBlockState(false);
}
