maddo/cirnogodot
1
0
Fork 0
mirror of https://gitlab.com/MaddoScientisto/cirnogodot.git synced 2026-06-07 17:45:54 +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

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;
}
}