/// <summary>
/// Updates the visible nodes according to the given step type.
/// </summary>
public void UpdateStep(PatchEntity data, Sfc2dEditorControl context)
{
if (data.SfcStepType != _currentStepType || _stepNode == null)
{
ShowStepAs(data.SfcStepType);
_currentStepType = data.SfcStepType;
}
_stepNode.SetEditorText(data.StepName, context);
}
/// <summary>
/// Updates the patch nodes according to the given data
/// </summary>
public void UpdateNodes(PatchEntity data)
{
GetNode <SfcStepNode>("SfcStepNode").UpdateStep(data, SfcPatchControl.Master);
GetNode <SfcLineButton>("SfcLineButtonTop").UpdateBranchLine(data.UpperBranch);
GetNode <SfcLineButton>("SfcLineButtonBot").UpdateBranchLine(data.LowerBranch);
GetNode <SfcTransitionNode>("SfcTransition").UpdateTransition(data.TransitionText, SfcPatchControl.Master);
GetNode <ActionEditorBox>("ActionEditorBox").UpdateActions(data, SfcPatchControl.Master.Data);
GetNode <SfcConnectionLine>("SfcConnectionLine").UpdateLine(data, SfcPatchControl);
}
/// <summary>
/// Called only once when the node is created by the patch control.
/// </summary>
public void InitializeWith(SfcPatchControl sfcPatchControl, PatchEntity data, bool isEditable)
{
SfcPatchControl = sfcPatchControl;
SetCellPosition(data.X, data.Y);
GetNode <SfcTransitionNode>("SfcTransition").Initialise();
GetNode <ActionEditorBox>("ActionEditorBox").InitializeWith(SfcPatchControl, isEditable);
Connect("mouse_entered", this, nameof(OnMouseEntered));
Connect("mouse_exited", this, nameof(OnMouseExited));
GetNode <Control>("MouseFilterEdit").Visible = !isEditable;
}
/// <summary>
/// Constructor. It will add the patch to the 2d editor.
/// </summary>
public SfcPatchControl(PatchEntity data, Sfc2dEditorControl control, bool isEditable)
{
Data = data;
Master = control;
SfcPatchMeta = new SfcPatchMeta();
Node node = ((PackedScene)GD.Load(_patchReferencePath)).Instance();
SfcPatchNode = (SfcPatchNode)node;
SfcPatchNode.InitializeWith(this, data, isEditable);
control.ReferenceRect.AddChild(SfcPatchNode);
}
/// <summary>
/// Ensures that a relevant patch has at least an empty patch on each side.
/// </summary>
private void EnsureNeighbours(PatchEntity patchData)
{
EnsurePatchAt(patchData.X + 1, patchData.Y);
EnsurePatchAt(patchData.X + 1, patchData.Y + 1);
EnsurePatchAt(patchData.X, patchData.Y + 1);
EnsurePatchAt(patchData.X - 1, patchData.Y + 1);
EnsurePatchAt(patchData.X - 1, patchData.Y);
EnsurePatchAt(patchData.X - 1, patchData.Y - 1);
EnsurePatchAt(patchData.X, patchData.Y - 1);
EnsurePatchAt(patchData.X + 1, patchData.Y - 1);
}
private void SetupDefaultSFC()
{
if (Data.SfcEntity.Lookup(1, 0) == null)
{
PatchEntity entity = new PatchEntity(1, 1)
{
SfcStepType = StepType.StartingStep
};
Data.SfcEntity.AddPatch(entity);
}
}
/// <summary>
/// Ensures that a patch field is aviable at the given position.
/// </summary>
private void EnsurePatchAt(int x, int y)
{
PatchEntity patch = Data.SfcEntity.Lookup(x, y);
if (patch == null)
{
Data.SfcEntity.CreatePatchAt((short)x, (short)y);
patch = Data.SfcEntity.Lookup(x, y);
SfcPatchControl control = new SfcPatchControl(patch, this, _isEditable);
_controlMap.Add(patch.Key, control);
}
}
/// <summary>
/// Loads the data from the stream. Written in "WriteTo".
/// </summary>
private void ReadFrom(BinaryReader reader)
{
PersistenceCheckHelper.CheckSectionNumber(reader, 0x11111111);
_patchMap.Clear();
int count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
PatchEntity entity = PatchEntity.CreateFrom(reader);
AddPatch(entity);
}
}
/// <summary>
/// Loads the data from the stream. Written in "WriteTo".
/// </summary>
public static PatchEntity CreateFrom(System.IO.BinaryReader reader)
{
short x = reader.ReadInt16();
short y = reader.ReadInt16();
PatchEntity entity = new PatchEntity(x, y)
{
SfcStepType = (StepType)reader.ReadInt32(),
StepName = reader.ReadString(),
UpperBranch = (BranchType)reader.ReadInt32(),
LowerBranch = (BranchType)reader.ReadInt32(),
TransitionText = reader.ReadString()
};
int entryCount = reader.ReadInt32();
for (int i = 0; i < entryCount; i++)
{
ActionEntity entry = ActionEntity.CreateFrom(reader);
entity.ActionEntries.Add(entry);
}
return(entity);
}
/// <summary>
/// Called when the model has changed or is initialized.
/// </summary>
public void UpdateActions(PatchEntity entity, IProcessingData context)
{
UpdateVisibility(entity);
for (int i = 0; i < entity.ActionEntries.Count; i++)
{
if (i >= _actionEditors.Count)
{
AddActionEditor(context);
}
_actionEditors[i].UpdateAction(entity.ActionEntries[i], context);
}
if (_isEditable)
{
if (entity.ActionEntries.Count >= _actionEditors.Count)
{
AddActionEditor(context);
}
_actionEditors[entity.ActionEntries.Count].ResetAction();
for (int i = entity.ActionEntries.Count + 1; i < _actionEditors.Count; i++)
{
RemoveActionEditor(_actionEditors[i]);
}
}
}
private void UpdateVisibility(PatchEntity entity)
{
Visible = entity.ContainsRealStep();
}
/// <summary>
/// Called when the model has changed or is initialized.
/// </summary>
public void UpdateLine(PatchEntity entity, SfcPatchControl control)
{
GetNode <ColorRect>("TransitionLineTop").Visible = entity.SfcStepType != StepType.Unused && entity.SfcStepType != StepType.Jump;
GetNode <ColorRect>("TransitionLineMid").Visible = entity.ContainsTransition() || control.SfcPatchMeta.HasPossibleTransitionSkip;
GetNode <ColorRect>("TransitionLineBot").Visible = control.SfcPatchMeta.RequestsLowerStepConnection;
}
/// <summary>
/// Adds the patch to the data map
/// </summary>
public void AddPatch(PatchEntity patch)
{
int key = CalculateMapKey(patch.X, patch.Y);
_patchMap.Add(key, patch);
}
/// <summary>
/// Creates a new patch at the given position and adds it to the map.
/// </summary>
public void CreatePatchAt(short x, short y)
{
PatchEntity entity = new PatchEntity(x, y);
AddPatch(entity);
}