vlad.os/LuaCsForBarotraumaEP
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Release 1.10.5.0 - Autumn Update 2025

Browse Source
This commit is contained in:
Regalis11
2025-09-17 13:44:21 +03:00
parent d13836ce87
commit caa0326cf8
120 changed files with 2584 additions and 635 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Barotrauma/BarotraumaClient/ClientSource/Screens/EventEditor/EventConversationNode.cs
+398
View File
@@ -0,0 +1,398 @@
#nullable enable
using System;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using System.Collections.Generic;
namespace Barotrauma
{
/// <summary>
/// Base class for event nodes that display text content and can have inner Text nodes
/// </summary>
internal abstract class EventTextDisplayNode(Type type, string name) : EventNode(type, name)
{
protected virtual bool ShowOptions => false;
private new Rectangle HeaderRectangle
{
get
{
if (!EventEditorScreen.ConversationMode) { return base.HeaderRectangle; }
Rectangle drawRect = GetDrawRectangle();
return new Rectangle(Position.ToPoint(), new Point(drawRect.Width, 32));
}
}
public override Rectangle GetDrawRectangle()
{
if (!EventEditorScreen.ConversationMode) { return base.GetDrawRectangle(); }
var textConnection = Connections.Find(c => string.Equals(c.Attribute, "Text", StringComparison.OrdinalIgnoreCase));
var optionConnections = ShowOptions ? Connections.Where(c => c.Type == NodeConnectionType.Option) : Enumerable.Empty<EventEditorNodeConnection>();
const int width = 300;
int height = 50;
// Calculate height for text section
if (textConnection != null)
{
string textContent = GetTextContent(textConnection);
if (!string.IsNullOrEmpty(textContent) && GUIStyle.Font.Value != null)
{
string wrappedText = ToolBox.WrapText(textContent, width - 16, GUIStyle.Font.Value);
Vector2 textSize = GUIStyle.Font.MeasureString(wrappedText);
height += (int)textSize.Y + 10;
}
else
{
height += 25;
}
}
// Calculate height for each option (only for conversation nodes)
if (ShowOptions)
{
int optionIndex = 0;
foreach (var option in optionConnections)
{
string optionText = GetOptionText(option, optionIndex);
if (GUIStyle.Font.Value != null)
{
string wrappedOption = ToolBox.WrapText(optionText, width - 40, GUIStyle.Font.Value);
Vector2 optionSize = GUIStyle.Font.MeasureString(wrappedOption);
height += (int)optionSize.Y + 20;
}
else
{
height += 40;
}
optionIndex++;
}
}
Rectangle rect = Rectangle;
return new Rectangle(rect.X, rect.Y, width, height);
}
protected override void DrawBack(SpriteBatch spriteBatch)
{
if (!EventEditorScreen.ConversationMode)
{
base.DrawBack(spriteBatch);
return;
}
Rectangle bodyRect = GetDrawRectangle();
// Background colors
Color headerColor = IsSelected ? new Color(100, 150, 200) : new Color(120, 170, 220);
Color bodyColor = new Color(90, 120, 150);
Color borderColor = Color.LightBlue;
// Draw background
GUI.DrawRectangle(spriteBatch, HeaderRectangle, headerColor, isFilled: true, depth: 1.0f);
GUI.DrawRectangle(spriteBatch, bodyRect, bodyColor, isFilled: true, depth: 1.0f);
GUI.DrawRectangle(spriteBatch, HeaderRectangle, borderColor, isFilled: false, depth: 1.0f);
GUI.DrawRectangle(spriteBatch, bodyRect, borderColor, isFilled: false, depth: 1.0f);
// Draw header text
Vector2 headerSize = GUIStyle.SubHeadingFont.MeasureString(Name);
Vector2 headerPos = HeaderRectangle.Location.ToVector2() + (HeaderRectangle.Size.ToVector2() / 2) - (headerSize / 2);
GUIStyle.SubHeadingFont.DrawString(spriteBatch, Name, headerPos, Color.White);
// Draw text content
DrawTextContent(spriteBatch, bodyRect);
// Let base class handle standard connections (Activate, Next, etc.)
DrawConnections(spriteBatch);
}
protected virtual void DrawTextContent(SpriteBatch spriteBatch, Rectangle bodyRect)
{
var textConnection = Connections.Find(c => string.Equals(c.Attribute, "Text", StringComparison.OrdinalIgnoreCase));
var optionConnections = ShowOptions ? Connections.Where(c => c.Type == NodeConnectionType.Option) : Enumerable.Empty<EventEditorNodeConnection>();
Vector2 mousePos = Screen.Selected.Cam.ScreenToWorld(PlayerInput.MousePosition);
mousePos.Y = -mousePos.Y;
const int padding = 8;
int currentY = bodyRect.Y + padding + 30;
// Draw text section
if (textConnection != null)
{
string textContent = GetTextContent(textConnection);
// Wrap text and calculate height
string wrappedText = textContent;
int textHeight = 25;
if (GUIStyle.Font.Value != null)
{
wrappedText = ToolBox.WrapText(textContent, bodyRect.Width - 24, GUIStyle.Font.Value);
Vector2 textSize = GUIStyle.Font.MeasureString(wrappedText);
textHeight = (int)textSize.Y + 10;
}
Rectangle textRect = new Rectangle(bodyRect.X + padding, currentY, bodyRect.Width - padding * 2, textHeight);
// background
GUI.DrawRectangle(spriteBatch, textRect, new Color(70, 100, 130), isFilled: true);
GUI.DrawRectangle(spriteBatch, textRect, Color.CornflowerBlue, isFilled: false);
// wrapped text
Vector2 textPos = new Vector2(textRect.X + 4, textRect.Y + 4);
GUI.DrawString(spriteBatch, textPos, wrappedText, Color.Yellow, font: GUIStyle.Font);
// tooltip
if (textRect.Contains(mousePos))
{
string rawTextKey = GetRawTextKey(textConnection);
if (!string.IsNullOrEmpty(rawTextKey))
{
EventEditorScreen.DrawnTooltip = rawTextKey;
}
}
currentY += textHeight + 5;
}
// Draw options (only for conversation nodes)
if (ShowOptions)
{
DrawOptions(spriteBatch, bodyRect, optionConnections, currentY);
}
}
protected static void DrawOptions(SpriteBatch spriteBatch, Rectangle bodyRect, IEnumerable<EventEditorNodeConnection> optionConnections, int startY)
{
Vector2 mousePos = Screen.Selected.Cam.ScreenToWorld(PlayerInput.MousePosition);
mousePos.Y = -mousePos.Y;
const int padding = 8;
int currentY = startY;
int optionIndex = 0;
foreach (var option in optionConnections)
{
string optionText = GetOptionText(option, optionIndex);
// Wrap option text and calculate height
string wrappedOption = optionText;
int optionHeight = 30;
if (GUIStyle.Font.Value != null)
{
wrappedOption = ToolBox.WrapText(optionText, bodyRect.Width - 40, GUIStyle.Font.Value);
Vector2 optionSize = GUIStyle.Font.MeasureString(wrappedOption);
optionHeight = (int)optionSize.Y + 16;
}
Rectangle optionRect = new Rectangle(bodyRect.X + padding, currentY, bodyRect.Width - padding * 2, optionHeight);
// background - red for end conversation, blue for normal
Color optionBg = option.EndConversation ? new Color(120, 80, 80) : new Color(80, 80, 120);
GUI.DrawRectangle(spriteBatch, optionRect, optionBg, isFilled: true);
GUI.DrawRectangle(spriteBatch, optionRect, Color.White, isFilled: false);
Vector2 optionPos = new Vector2(optionRect.X + 4, optionRect.Y + 4);
GUI.DrawString(spriteBatch, optionPos, wrappedOption, Color.White, font: GUIStyle.Font);
// tooltip
if (optionRect.Contains(mousePos))
{
string rawOptionKey = option.OptionText ?? "";
if (!string.IsNullOrEmpty(rawOptionKey))
{
EventEditorScreen.DrawnTooltip = rawOptionKey;
}
}
// connection point
Rectangle connRect = new Rectangle(bodyRect.Right - 1, optionRect.Y + optionHeight / 2 - 8, 16, 16);
GUI.DrawRectangle(spriteBatch, connRect, Color.DarkGray, isFilled: true);
GUI.DrawRectangle(spriteBatch, connRect, Color.White, isFilled: false);
option.DrawRectangle = connRect;
// connection lines
foreach (var connected in option.ConnectedTo)
{
Vector2 start = new Vector2(connRect.Right, connRect.Center.Y);
Vector2 end = new Vector2(connected.DrawRectangle.Left, connected.DrawRectangle.Center.Y);
float knobLength = 24;
var (points, _) = ToolBox.GetSquareLineBetweenPoints(start, end, knobLength);
Color lineColor = GUIStyle.Red;
float lineWidth = Math.Max(2.0f, 2.0f / (Screen.Selected is EventEditorScreen eventEditor ? eventEditor.Cam.Zoom : 1.0f));
GUI.DrawLine(spriteBatch, points[0], points[1], lineColor, width: (int)lineWidth);
GUI.DrawLine(spriteBatch, points[1], points[2], lineColor, width: (int)lineWidth);
GUI.DrawLine(spriteBatch, points[2], points[3], lineColor, width: (int)lineWidth);
GUI.DrawLine(spriteBatch, points[3], points[4], lineColor, width: (int)lineWidth);
GUI.DrawLine(spriteBatch, points[4], points[5], lineColor, width: (int)lineWidth);
}
currentY += optionHeight + 5;
optionIndex++;
}
}
private static string GetOptionText(EventEditorNodeConnection option, int optionIndex)
{
string optionTextKey = option.OptionText ?? $"Option {optionIndex + 1}";
var allVariants = TextManager.GetAll(optionTextKey);
int variantCount = allVariants.Count();
return variantCount switch
{
> 1 => $"[{variantCount} variants] {string.Join(" / ", allVariants)}",
1 => allVariants.First(),
_ => optionTextKey
};
}
private string GetTextContent(EventEditorNodeConnection textConnection)
{
string textContent = "";
// First check if there's a direct text attribute
if (textConnection.OverrideValue != null)
{
textContent = textConnection.OverrideValue.ToString() ?? "";
}
else
{
object? connectedValue = textConnection.GetValue();
if (connectedValue != null)
{
textContent = connectedValue.ToString() ?? "";
}
}
// If no direct text, check for inner Text nodes via Add connections
if (string.IsNullOrEmpty(textContent))
{
var addConnection = Connections.FirstOrDefault(c => c.Type == NodeConnectionType.Add);
if (addConnection != null && addConnection.ConnectedTo.Any())
{
var connectedNode = addConnection.ConnectedTo.First();
if (connectedNode.Parent?.Name == "Text")
{
// Get the text content from the connected Text node
var textNodeConnection = connectedNode.Parent.Connections.FirstOrDefault(c =>
string.Equals(c.Attribute, "tag", StringComparison.OrdinalIgnoreCase));
if (textNodeConnection?.OverrideValue != null)
{
textContent = textNodeConnection.OverrideValue.ToString() ?? "";
}
}
}
}
// Translate the text if we found any
if (!string.IsNullOrEmpty(textContent))
{
var translated = TextManager.Get(textContent);
if (translated.Loaded)
{
textContent = translated.Value;
}
}
return textContent;
}
private string GetRawTextKey(EventEditorNodeConnection textConnection)
{
string textKey = "";
// First check if there's a direct text attribute
if (textConnection.OverrideValue != null)
{
textKey = textConnection.OverrideValue.ToString() ?? "";
}
else
{
var connectedValue = textConnection.GetValue();
if (connectedValue != null)
{
textKey = connectedValue.ToString() ?? "";
}
}
// If no direct text, check for inner Text nodes via Add connections
if (string.IsNullOrEmpty(textKey))
{
var addConnection = Connections.FirstOrDefault(c => c.Type == NodeConnectionType.Add);
if (addConnection != null && addConnection.ConnectedTo.Any())
{
var connectedNode = addConnection.ConnectedTo.First();
if (connectedNode.Parent?.Name == "Text")
{
// Get the text key from the connected Text node
var textNodeConnection = connectedNode.Parent.Connections.FirstOrDefault(c =>
string.Equals(c.Attribute, "tag", StringComparison.OrdinalIgnoreCase));
if (textNodeConnection?.OverrideValue != null)
{
textKey = textNodeConnection.OverrideValue.ToString() ?? "";
}
}
}
}
return textKey;
}
protected override bool ShouldDrawConnection(EventEditorNodeConnection connection)
{
if (!EventEditorScreen.ConversationMode) { return base.ShouldDrawConnection(connection); }
// In conversation mode, exclude Options and Text since we draw them manually
// Also exclude Add connections since we hide the child Text nodes and display their content inline
return connection.Type == NodeConnectionType.Activate ||
connection.Type == NodeConnectionType.Next;
}
protected override void DrawConnections(SpriteBatch spriteBatch)
{
if (!EventEditorScreen.ConversationMode)
{
base.DrawConnections(spriteBatch);
return;
}
// In conversation mode, use the correct rectangle for connection positioning
Rectangle correctRect = GetDrawRectangle();
int x = 0, y = 0;
foreach (EventEditorNodeConnection connection in Connections)
{
if (!ShouldDrawConnection(connection)) { continue; }
switch (connection.Type.NodeSide)
{
case NodeConnectionType.Side.Left:
connection.Draw(spriteBatch, correctRect, y);
y++;
break;
case NodeConnectionType.Side.Right:
connection.Draw(spriteBatch, correctRect, x);
x++;
break;
}
}
}
}
internal class EventConversationNode(Type type, string name) : EventTextDisplayNode(type, name)
{
protected override bool ShowOptions => true;
}
internal class EventLogNode(Type type, string name) : EventTextDisplayNode(type, name)
{
protected override bool ShowOptions => false;
}
}