maddo/cirnogodot
1
0
Fork 0
mirror of https://gitlab.com/MaddoScientisto/cirnogodot.git synced 2026-06-09 09:05:53 +00:00
Code Issues Projects Releases Packages Wiki Activity

Remade resource script system

Browse source
This commit is contained in:
MaddoScientisto 2025-03-15 17:17:30 +01:00
commit 029128c8b8
17 changed files with 576 additions and 386 deletions
Download patch file Download diff file Expand all files Collapse all files

44
Scripts/Actors/ScriptableBulletsEmitter.cs
View file

@ -5,17 +5,40 @@ using Godot;
namespace Cirno.Scripts.Actors;
public partial class ScriptableBulletsEmitter : Area2D, IActivable, IScriptHost
public partial class ScriptableBulletsEmitter : Node2D, IActivable, IScriptHost
{
[Export]
public BulletScript Script { get; private set; }
[Export]
public bool InvertSignal { get; private set; } = false;
[Export]
public bool EmitOnStart { get; set; } = false;
[Signal]
public delegate void StateChangedEventHandler(bool isEmitting);
private bool _isActive = false;
//private BulletScript _scriptInstance;
protected BulletScript.BulletScriptMachine ScriptMachine;
public override void _Ready()
{
//_scriptInstance = Script.Duplicate(true) as BulletScript;
ScriptMachine = Script.Make(this);
_homePosition = this.GlobalPosition;
if (EmitOnStart)
{
_isActive = true;
ScriptMachine.Start();
}
EmitSignal(SignalName.StateChanged, _isActive);
}
public bool Activate(ActivationType activationType = ActivationType.Toggle)
@ -26,23 +49,26 @@ public partial class ScriptableBulletsEmitter : Area2D, IActivable, IScriptHost
case ActivationType.Toggle:
_isActive = !_isActive;
break;
case ActivationType.Close:
case ActivationType.Enable:
_isActive = true;
break;
case ActivationType.Open:
case ActivationType.Enable:
_isActive = !InvertSignal;
break;
case ActivationType.Close:
case ActivationType.Disable:
_isActive = false;
_isActive = InvertSignal;
break;
case ActivationType.Destroy:
_isActive = false;
_isActive = InvertSignal;
// TODO: Explode
break;
}
if (_isActive)
{
Script.Start(this);
ScriptMachine.Start();
}
EmitSignal(SignalName.StateChanged, _isActive);
return true;
}
@ -51,7 +77,7 @@ public partial class ScriptableBulletsEmitter : Area2D, IActivable, IScriptHost
{
if (!_isActive) return;
Script.UpdatePhase(delta);
ScriptMachine.UpdatePhase(delta);
}
private Vector2 _homePosition;

15
Scripts/AttackPatterns/IPatternMachine.cs Normal file
View file

@ -0,0 +1,15 @@
using Cirno.Scripts.Resources;
using Godot;
namespace Cirno.Scripts.AttackPatterns;
public interface IPatternMachine
{
public Node2D Parent { get; }
public void Start();
public void UpdatePattern(double delta);
public bool IsComplete();
}

96
Scripts/AttackPatterns/MovementPattern.cs
View file

@ -7,52 +7,66 @@ namespace Cirno.Scripts.AttackPatterns;
[GlobalClass]
public partial class MovementPattern : AttackPattern
{
[Export] private Vector2 relativeTargetPosition;
[Export] private float moveDuration = 2f;
[Export] private Tween.TransitionType transitionType = Tween.TransitionType.Linear;
[Export] private Tween.EaseType easeType = Tween.EaseType.InOut;
[Export] private AttackPattern shootingPattern;
[Export] public Vector2 relativeTargetPosition;
[Export] public float moveDuration = 2f;
[Export] public Tween.TransitionType transitionType = Tween.TransitionType.Linear;
[Export] public Tween.EaseType easeType = Tween.EaseType.InOut;
[Export] public AttackPattern shootingPattern;
private Tween tween;
private bool isComplete = false;
protected IScriptHost Boss;
public override void Start(Node2D parent)
public override IPatternMachine MakeMachine(Node2D parent)
{
if (parent is not IScriptHost boss)
return;
Boss = boss;
tween = parent.CreateTween();
isComplete = false;
Vector2 targetPosition = (Boss?.HomePosition ?? parent.GlobalPosition) + this.relativeTargetPosition;
tween.TweenProperty(Parent, "position", targetPosition, moveDuration)
.SetTrans(transitionType)
.SetEase(easeType)
.Finished += () => isComplete = true;
if (shootingPattern != null && !WaitForCompletion)
{
shootingPattern.Start(Parent);
}
return new MovementPatternMachine(this, parent);
}
public override void UpdatePattern(double delta)
public class MovementPatternMachine(MovementPattern pattern, Node2D parent) : IPatternMachine
{
if (shootingPattern != null && !WaitForCompletion)
{
shootingPattern.UpdatePattern(delta);
}
}
public Node2D Parent => parent;
public MovementPattern Pattern { get; } = pattern;
private IPatternMachine _machine;
public override bool IsComplete()
{
if (WaitForCompletion && shootingPattern != null)
return isComplete && shootingPattern.IsComplete();
return isComplete;
private Tween tween;
private bool isComplete = false;
protected IScriptHost Boss;
public void Start()
{
if (parent is not IScriptHost boss)
return;
Boss = boss;
tween = parent.CreateTween();
isComplete = false;
Vector2 targetPosition = (Boss?.HomePosition ?? parent.GlobalPosition) + Pattern.relativeTargetPosition;
tween.TweenProperty(Parent, "position", targetPosition, Pattern.moveDuration)
.SetTrans(Pattern.transitionType)
.SetEase(Pattern.easeType)
.Finished += () => isComplete = true;
if (Pattern.shootingPattern != null && !Pattern.WaitForCompletion)
{
_machine = Pattern.shootingPattern.MakeMachine(parent);
_machine.Start();
}
}
public void UpdatePattern(double delta)
{
if (_machine is not null && !Pattern.WaitForCompletion)
{
_machine.UpdatePattern(delta);
//shootingPattern.UpdatePattern(delta);
}
}
public bool IsComplete()
{
if (Pattern.WaitForCompletion && _machine is not null)
return isComplete && _machine.IsComplete();
return isComplete;
}
}
}

60
Scripts/AttackPatterns/PatternTest.cs
View file

@ -9,37 +9,47 @@ namespace Cirno.Scripts.AttackPatterns;
public partial class PatternTest : AttackPattern
{
[Export] public PackedScene BulletScene;
[Export] private float bulletSpeed = 5f;
[Export] private int bulletCount = 12;
[Export] private float duration = 3f;
[Export] private float burstInterval = 0.5f;
[Export] private BulletOwner owner = BulletOwner.Enemy;
private double timer;
private double burstTimer;
private BulletSpawner spawner;
public override void Start(Node2D parent)
[Export] public float bulletSpeed = 5f;
[Export] public int bulletCount = 12;
[Export] public float duration = 3f;
[Export] public float burstInterval = 0.5f;
[Export] public BulletOwner owner = BulletOwner.Enemy;
public override IPatternMachine MakeMachine(Node2D parent)
{
Parent = parent;
timer = 0;
burstTimer = 0;
spawner = Parent.GetNode<BulletSpawner>("BulletSpawner");
return new PatternTestMachine(this, parent);
}
public override void UpdatePattern(double delta)
public class PatternTestMachine(PatternTest pattern, Node2D parent) : IPatternMachine
{
timer += delta;
burstTimer += delta;
if (timer < duration && burstTimer >= burstInterval)
public Node2D Parent => parent;
private double timer;
private double burstTimer;
private BulletSpawner spawner;
public void Start()
{
spawner.SpawnBullet(Parent.GlobalPosition, Vector2.Right, bulletSpeed, owner, bulletCount, bulletScene: BulletScene);
timer = 0;
burstTimer = 0;
spawner = Parent.GetNode<BulletSpawner>("BulletSpawner");
}
public void UpdatePattern(double delta)
{
timer += delta;
burstTimer += delta;
if (timer < pattern.duration && burstTimer >= pattern.burstInterval)
{
spawner.SpawnBullet(Parent.GlobalPosition, Vector2.Right, pattern.bulletSpeed, pattern.owner, pattern.bulletCount, bulletScene: pattern.BulletScene);
burstTimer = 0;
}
}
public bool IsComplete()
{
return timer >= pattern.duration;
}
}
public override bool IsComplete()
{
return timer >= duration;
}
}

235
Scripts/AttackPatterns/SpiralPattern.cs
View file

@ -1,4 +1,5 @@
using System.Collections.Generic;
using System;
using System.Collections.Generic;
using System.Linq;
using Cirno.Scripts.Actors;
using Cirno.Scripts.Components;
@ -13,82 +14,28 @@ namespace Cirno.Scripts.AttackPatterns;
public partial class SpiralPattern : AttackPattern
{
[Export] public BulletResource BulletResource { get; set; }
//Export] public PackedScene BulletScene;
//[Export] private float _bulletLifeTime = 20f; // Switch to res
//[Export] private bool _destroyOnCollision = false; // Switch to res
//[Export] private float bulletSpeed = 5f; // Switch to res
[Export] private int bulletCount = 16;
[Export] private float rotationSpeed = 0f;
[Export] private float _rotationOffset = 0f;
[Export] private float duration = 5f;
[Export] private float burstInterval = 0.5f;
[Export] private float spread = 360f;
[Export] public int bulletCount = 16;
[Export] public float rotationSpeed = 0f;
[Export] public float _rotationOffset = 0f;
[Export] public float duration = 5f;
[Export] public float spread = 360f;
[Export] public float burstInterval = 0.5f;
[ExportCategory("Burst")] [Export] public int ShotsPerBurst { get; private set; } = 100;
[Export] public float BurstRate { get; private set; } = 0f;
//[Export] private BulletOwner owner = BulletOwner.Enemy; // Switch to res
//[Export] private DamageType _damageType = DamageType.Neutral; // Switch to res
//[Export] private float _bulletDamage = 1f; // Switch to res
[ExportGroup("Modifiers")]
[Export] private BulletCreationModifier _modifier;
[ExportGroup("Modifiers")]
[Export] private Array<TimeModifier> _timeModifiers;
[Export] private bool _targetPlayer = false;
private double timer;
private double burstTimer;
private BulletSpawner spawner;
public override void Start(Node2D parent)
{
Parent = parent;
timer = 0;
burstTimer = burstInterval; // start immediately
spawner = parent.GetNode<BulletSpawner>("BulletSpawner");
}
public override void UpdatePattern(double delta)
{
timer += delta;
burstTimer += delta;
if (timer < duration && burstTimer >= burstInterval)
{
float angleOffset = _rotationOffset + (float)(rotationSpeed * timer);
Vector2 direction = BulletResource.Direction;
if (_targetPlayer && GameManager.Instance.PlayerPosition.HasValue)
{
direction = (GameManager.Instance.PlayerPosition.Value - Parent.GlobalPosition).Normalized();
}
var bullet = BulletResource.MakeBullet(Parent.GlobalPosition, bulletCount, spread, angleOffset);
bullet.Direction = direction;
//spawner.SpawnBullet(MakeBullet(Boss.GlobalPosition, direction, angleOffset));
spawner.SpawnBullet(bullet);
// spawner.SpawnBullet(new BulletInfo()
// {
// Position = Boss.GlobalPosition,
// Direction = direction,
// Speed = bulletSpeed,
// Owner = owner,
// DamageType = _damageType,
// Damage = _bulletDamage,
// BulletCount = bulletCount,
// Spread = spread,
// BulletScene = BulletScene,
// RotationOffset = angleOffset,
// Modifier = _modifier,
// TimeModifiers = ((_timeModifiers?.Where(mod => mod != null)) ?? Array.Empty<TimeModifier>()).Select(m => new ModifierWrapper()
// {
// TimeModifier = m,
// Applied = false
// }).ToList()
// });
burstTimer = 0;
}
}
// [ExportGroup("Modifiers")] [Export] private BulletCreationModifier _modifier;
// [ExportGroup("Modifiers")] [Export] private Array<TimeModifier> _timeModifiers;
[ExportCategory("Other")] [Export] public bool _targetPlayer = false;
protected virtual BulletInfo MakeBullet(Vector2 position, Vector2 direction, float angleOffset)
{
@ -96,7 +43,7 @@ public partial class SpiralPattern : AttackPattern
bl.Direction = direction;
return bl;
// return new BulletInfo()
// {
// Position = position,
@ -117,8 +64,148 @@ public partial class SpiralPattern : AttackPattern
// };
}
public override bool IsComplete()
public override IPatternMachine MakeMachine(Node2D parent)
{
return timer >= duration;
return new SpiralPatternMachine(this, parent);
}
}
public class SpiralPatternMachine(SpiralPattern pattern, Node2D parent) : IPatternMachine
{
public Node2D Parent => parent;
private double timer;
private double burstTimer;
//private double _burstRateTimer;
private BulletSpawner spawner;
private ShootStatus _state = ShootStatus.Idle;
private int _burstBullets;
public void Start()
{
timer = 0;
_burstBullets = pattern.ShotsPerBurst;
burstTimer = pattern.burstInterval; // start immediately
//_burstRateTimer = pattern.burstInterval;
spawner = parent.GetNode<BulletSpawner>("BulletSpawner");
_state = ShootStatus.Shooting;
}
private void WaitingBurstUpdate(double delta)
{
timer += delta;
burstTimer += delta;
if (burstTimer >= pattern.burstInterval)
{
_state = ShootStatus.Shooting;
}
}
private void WaitingReloadUpdate(double delta)
{
timer += delta;
burstTimer += delta;
if (burstTimer >= pattern.BurstRate)
{
_burstBullets = pattern.ShotsPerBurst;
_state = ShootStatus.Shooting;
}
}
private void ShootingUpdate(double delta)
{
timer += delta;
burstTimer = 0;
Shoot();
_burstBullets--;
if (_burstBullets <= 0)
{
_state = ShootStatus.WaitingReload;
}
else
{
_state = ShootStatus.WaitingBurst;
}
}
public void UpdatePattern(double delta)
{
switch (_state)
{
case ShootStatus.Idle:
case ShootStatus.Done:
return;
case ShootStatus.Shooting:
ShootingUpdate(delta);
break;
case ShootStatus.WaitingBurst:
WaitingBurstUpdate(delta);
break;
case ShootStatus.WaitingReload:
WaitingReloadUpdate(delta);
break;
}
if (timer >= pattern.duration)
{
_state = ShootStatus.Done;
}
// timer += delta;
// burstTimer += delta;
// //_burstRateTimer += delta;
//
// if (timer > pattern.duration)
// {
// return;
// }
//
// if (burstTimer < pattern.burstInterval) return;
//
// Shoot();
//
//
//
// burstTimer = 0;
}
private void Shoot()
{
float angleOffset = pattern._rotationOffset + (float)(pattern.rotationSpeed * timer);
Vector2 direction = pattern.BulletResource.Direction;
if (pattern._targetPlayer && GameManager.Instance.PlayerPosition.HasValue)
{
direction = (GameManager.Instance.PlayerPosition.Value - Parent.GlobalPosition).Normalized();
}
var bullet = pattern.BulletResource.MakeBullet(Parent.GlobalPosition, pattern.bulletCount,
pattern.spread, angleOffset);
bullet.Direction = direction;
//spawner.SpawnBullet(MakeBullet(Boss.GlobalPosition, direction, angleOffset));
spawner.SpawnBullet(bullet);
}
public bool IsComplete()
{
//return timer >= pattern.duration;
return _state is ShootStatus.Done;
}
private enum ShootStatus
{
Idle,
Shooting,
WaitingBurst,
WaitingReload,
Done
}
}
}

52
Scripts/AttackPatterns/TargetedPattern.cs
View file

@ -19,34 +19,42 @@ public partial class TargetedPattern : AttackPattern
[Export] private BulletOwner owner = BulletOwner.Enemy;
[Export] private BulletCreationModifier modifier;
private double timer;
private double burstTimer;
private BulletSpawner spawner;
//private Node2D player;
public override void Start(Node2D parent)
public override IPatternMachine MakeMachine(Node2D parent)
{
Parent = parent;
timer = 0;
burstTimer = 0;
spawner = Parent.GetNode<BulletSpawner>("BulletSpawner");
return new TargetedPatternMachine(this, parent);
}
public override void UpdatePattern(double delta)
public class TargetedPatternMachine(TargetedPattern pattern, Node2D parent) : IPatternMachine
{
timer += delta;
burstTimer += delta;
if (timer < duration && burstTimer >= burstInterval && GameManager.Instance.PlayerPosition.HasValue)
public Node2D Parent => parent;
private double timer;
private double burstTimer;
private BulletSpawner spawner;
//private Node2D player;
public void Start()
{
spawner.SpawnTargetedBullet(Parent.GlobalPosition, GameManager.Instance.PlayerPosition.Value, bulletSpeed, owner, BulletScene, bulletsPerShot, spread, modifier);
timer = 0;
burstTimer = 0;
spawner = Parent.GetNode<BulletSpawner>("BulletSpawner");
}
public void UpdatePattern(double delta)
{
timer += delta;
burstTimer += delta;
if (timer < pattern.duration && burstTimer >= pattern.burstInterval && GameManager.Instance.PlayerPosition.HasValue)
{
spawner.SpawnTargetedBullet(Parent.GlobalPosition, GameManager.Instance.PlayerPosition.Value, pattern.bulletSpeed, pattern.owner, pattern.BulletScene, pattern.bulletsPerShot, pattern.spread, pattern.modifier);
burstTimer = 0;
}
}
public bool IsComplete()
{
return timer >= pattern.duration;
}
}
public override bool IsComplete()
{
return timer >= duration;
}
}

10
Scripts/Resources/AttackPattern.cs
View file

@ -1,4 +1,5 @@
using Cirno.Scripts.Actors;
using Cirno.Scripts.AttackPatterns;
using Godot;
namespace Cirno.Scripts.Resources;
@ -6,9 +7,10 @@ namespace Cirno.Scripts.Resources;
[GlobalClass]
public abstract partial class AttackPattern : Resource
{
public Node2D Parent;
//public Node2D Parent;
[Export] public bool WaitForCompletion = true;
public abstract void Start(Node2D parent);
public abstract void UpdatePattern(double delta);
public abstract bool IsComplete();
//public abstract void Start(Node2D parent);
//public abstract void UpdatePattern(double delta);
//public abstract bool IsComplete();
public abstract IPatternMachine MakeMachine(Node2D parent);
}

16
Scripts/Resources/BossPhase.cs
View file

@ -1,4 +1,5 @@
using Cirno.Scripts.Actors;
using Cirno.Scripts.AttackPatterns;
using Godot;
using Godot.Collections;
@ -15,10 +16,14 @@ public partial class BossPhase : Resource
private int currentPatternIndex = 0;
private double patternTimer;
private IPatternMachine _patternMachine;
public void Start(Boss boss)
{
currentPatternIndex = 0;
Patterns[currentPatternIndex].Start(boss);
_patternMachine = Patterns[currentPatternIndex].MakeMachine(boss);
_patternMachine.Start();
//Patterns[currentPatternIndex].Start(boss);
}
public void UpdatePhase(double delta)
@ -26,12 +31,15 @@ public partial class BossPhase : Resource
patternTimer += delta;
var currentPattern = Patterns[currentPatternIndex];
currentPattern.UpdatePattern(delta);
_patternMachine.UpdatePattern(delta);
if (!currentPattern.WaitForCompletion || currentPattern.IsComplete())
if (!currentPattern.WaitForCompletion || _patternMachine.IsComplete())
{
currentPatternIndex = (currentPatternIndex + 1) % Patterns.Count;
Patterns[currentPatternIndex].Start(currentPattern.Parent);
var oldParent = _patternMachine.Parent;
_patternMachine = Patterns[currentPatternIndex].MakeMachine(oldParent);
_patternMachine.Start();
//_patternMachine.Start(currentPattern.Parent);
}
}
}

51
Scripts/Resources/BulletScript.cs
View file

@ -1,4 +1,5 @@
using System.Linq;
using Cirno.Scripts.AttackPatterns;
using Godot;
using Godot.Collections;
@ -9,33 +10,43 @@ public partial class BulletScript : Resource
{
[Export]
public Array<AttackPattern> Patterns { get; private set; }
private Node2D _parent;
private int _currentPatternIndex = 0;
private double _patternTimer;
private AttackPattern CurrentPattern => Patterns[_currentPatternIndex];
public void Start(Node2D parent)
public BulletScriptMachine Make(Node2D parent)
{
_parent = parent;
if (Patterns.Count == 0) return;
_currentPatternIndex = 0;
CurrentPattern.Start(parent);
return new BulletScriptMachine(parent, Patterns);
}
public void UpdatePhase(double delta)
public class BulletScriptMachine(Node2D parent, Array<AttackPattern> patterns)
{
_patternTimer += delta;
CurrentPattern.UpdatePattern(delta);
private int _currentPatternIndex = 0;
//private double _patternTimer;
private AttackPattern CurrentPattern => patterns[_currentPatternIndex];
if (!CurrentPattern.WaitForCompletion || CurrentPattern.IsComplete())
private IPatternMachine _currentPatternMachine;
public void Start()
{
_currentPatternIndex = (_currentPatternIndex + 1) % Patterns.Count;
CurrentPattern.Start(_parent);
if (patterns.Count == 0) return;
_currentPatternIndex = 0;
_currentPatternMachine = CurrentPattern.MakeMachine(parent);
_currentPatternMachine.Start();
}
public void UpdatePhase(double delta)
{
//_patternTimer += delta;
_currentPatternMachine.UpdatePattern(delta);
//CurrentPattern.UpdatePattern(delta);
if (!CurrentPattern.WaitForCompletion || _currentPatternMachine.IsComplete())
{
_currentPatternIndex = (_currentPatternIndex + 1) % patterns.Count;
_currentPatternMachine = CurrentPattern.MakeMachine(parent);
_currentPatternMachine.Start();
}
}
}
}

48
Scripts/Resources/PatternGroup.cs
View file

@ -1,6 +1,7 @@
using Godot;
using System.Collections.Generic;
using Cirno.Scripts.Actors;
using Cirno.Scripts.AttackPatterns;
using Godot.Collections;
namespace Cirno.Scripts.Resources;
@ -9,34 +10,47 @@ namespace Cirno.Scripts.Resources;
public partial class PatternGroup : AttackPattern
{
[Export] private Array<AttackPattern> patterns;
private int currentPatternIndex = 0;
public override void Start(Node2D parent)
public override IPatternMachine MakeMachine(Node2D parent)
{
Parent = parent;
currentPatternIndex = 0;
patterns[currentPatternIndex].Start(parent);
return new PatternGroupMachine(this, parent);
}
public override void UpdatePattern(double delta)
public class PatternGroupMachine(PatternGroup pattern, Node2D parent) : IPatternMachine
{
if (currentPatternIndex < patterns.Count)
public Node2D Parent => parent;
private int currentPatternIndex = 0;
IPatternMachine _patternMachine;
public void Start()
{
patterns[currentPatternIndex].UpdatePattern(delta);
currentPatternIndex = 0;
_patternMachine = pattern.patterns[currentPatternIndex].MakeMachine(parent);
_patternMachine.Start();
}
if (!patterns[currentPatternIndex].WaitForCompletion || patterns[currentPatternIndex].IsComplete())
public void UpdatePattern(double delta)
{
if (currentPatternIndex < pattern.patterns.Count)
{
currentPatternIndex++;
if (currentPatternIndex < patterns.Count)
_patternMachine.UpdatePattern(delta);
if (!pattern.patterns[currentPatternIndex].WaitForCompletion || _patternMachine.IsComplete())
{
patterns[currentPatternIndex].Start(Parent);
currentPatternIndex++;
if (currentPatternIndex < pattern.patterns.Count)
{
_patternMachine.Start();
}
}
}
}
}
public override bool IsComplete()
{
return currentPatternIndex >= patterns.Count;
public bool IsComplete()
{
return currentPatternIndex >= pattern.patterns.Count;
}
}
}

67
Scripts/Resources/SimpleMovementPattern.cs
View file

@ -12,38 +12,47 @@ public partial class SimpleMovementPattern : AttackPattern
[Export] private Tween.TransitionType transitionType = Tween.TransitionType.Linear;
[Export] private Tween.EaseType easeType = Tween.EaseType.InOut;
private Tween tween;
private bool isComplete = false;
protected IScriptHost Boss;
public override void Start(Node2D parent)
public override IPatternMachine MakeMachine(Node2D parent)
{
Parent = parent;
if (parent is not IScriptHost boss)
return;
Boss = boss;
tween = Parent.CreateTween();
isComplete = false;
Vector2 targetPosition = (Boss?.HomePosition ?? Parent.GlobalPosition) + relativeTargetPosition;
boss.ChangeSpriteDirection(-(Parent.GlobalPosition - targetPosition));
tween.TweenProperty(Parent, "global_position", targetPosition, moveDuration)
.SetTrans(transitionType)
.SetEase(easeType)
.Finished += () =>
{
isComplete = true;
boss.ChangeSpriteDirection(Vector2.Zero);
};
return new SimpleMovementPatternMachine(this, parent);
}
public override void UpdatePattern(double delta) { }
public override bool IsComplete()
public class SimpleMovementPatternMachine(SimpleMovementPattern pattern, Node2D parent) : IPatternMachine
{
return isComplete;
public Node2D Parent => parent;
private Tween tween;
private bool isComplete = false;
protected IScriptHost Boss;
public void Start()
{
if (parent is not IScriptHost boss)
return;
Boss = boss;
tween = Parent.CreateTween();
isComplete = false;
Vector2 targetPosition = (Boss?.HomePosition ?? Parent.GlobalPosition) + pattern.relativeTargetPosition;
boss.ChangeSpriteDirection(-(Parent.GlobalPosition - targetPosition));
tween.TweenProperty(Parent, "global_position", targetPosition, pattern.moveDuration)
.SetTrans(pattern.transitionType)
.SetEase(pattern.easeType)
.Finished += () =>
{
isComplete = true;
boss.ChangeSpriteDirection(Vector2.Zero);
};
}
public void UpdatePattern(double delta) { }
public bool IsComplete()
{
return isComplete;
}
}
}