Simple Magic Spellbook System (#7823)

Co-authored-by: metalgearsloth <comedian_vs_clown@hotmail.com>

Content.Server/Magic/Components/SpellbookComponent.cs

@@ -0,0 +1,36 @@
+using System.Threading;
+using Content.Shared.Actions.ActionTypes;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype.Dictionary;
+
+namespace Content.Server.Magic;
+
+/// <summary>
+/// Spellbooks for having an entity learn spells as long as they've read the book and it's in their hand.
+/// </summary>
+[RegisterComponent]
+public sealed class SpellbookComponent : Component
+{
+    /// <summary>
+    /// List of spells that this book has. This is a combination of the WorldSpells, EntitySpells, and InstantSpells.
+    /// </summary>
+    [ViewVariables]
+    public readonly List<ActionType> Spells = new();
+
+    /// <summary>
+    /// The three fields below is just used for initialization.
+    /// </summary>
+    [DataField("worldSpells", customTypeSerializer: typeof(PrototypeIdDictionarySerializer<int, WorldTargetActionPrototype>))]
+    public readonly Dictionary<string, int> WorldSpells = new();
+
+    [DataField("entitySpells", customTypeSerializer: typeof(PrototypeIdDictionarySerializer<int, EntityTargetActionPrototype>))]
+    public readonly Dictionary<string, int> EntitySpells = new();
+
+    [DataField("instantSpells", customTypeSerializer: typeof(PrototypeIdDictionarySerializer<int, InstantActionPrototype>))]
+    public readonly Dictionary<string, int> InstantSpells = new();
+
+    [ViewVariables]
+    [DataField("learnTime")]
+    public float LearnTime = .75f;
+
+    public CancellationTokenSource? CancelToken;
+}

Content.Server/Magic/Events/InstantSpawnSpellEvent.cs

@@ -0,0 +1,42 @@
+using Content.Shared.Actions;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
+
+namespace Content.Server.Magic.Events;
+
+public sealed class InstantSpawnSpellEvent : InstantActionEvent
+{
+    /// <summary>
+    /// What entity should be spawned.
+    /// </summary>
+    [DataField("prototype", required: true, customTypeSerializer: typeof(PrototypeIdSerializer<EntityPrototype>))]
+    public string Prototype = default!;
+
+    [ViewVariables, DataField("preventCollide")]
+    public bool PreventCollideWithCaster = true;
+
+    /// <summary>
+    /// Gets the targeted spawn positons; may lead to multiple entities being spawned.
+    /// </summary>
+    [DataField("posData")] public MagicSpawnData Pos = new TargetCasterPos();
+}
+
+[ImplicitDataDefinitionForInheritors]
+public abstract class MagicSpawnData
+{
+
+}
+
+/// <summary>
+/// Spawns 1 at the caster's feet.
+/// </summary>
+public sealed class TargetCasterPos : MagicSpawnData {}
+
+/// <summary>
+/// Targets the 3 tiles in front of the caster.
+/// </summary>
+public sealed class TargetInFront : MagicSpawnData
+{
+    [DataField("width")]
+    public int Width = 3;
+}

Content.Server/Magic/Events/KnockSpellEvent.cs

@@ -0,0 +1,24 @@
+using Content.Shared.Actions;
+using Content.Shared.Sound;
+
+namespace Content.Server.Magic.Events;
+
+public sealed class KnockSpellEvent : InstantActionEvent
+{
+    /// <summary>
+    /// The range this spell opens doors in
+    /// 4f is the default
+    /// </summary>
+    [DataField("range")]
+    public float Range = 4f;
+
+    [DataField("knockSound")]
+    public SoundSpecifier KnockSound = new SoundPathSpecifier("/Audio/Magic/knock.ogg");
+
+    /// <summary>
+    /// Volume control for the spell.
+    /// -6f is default because the base soundfile is really loud
+    /// </summary>
+    [DataField("knockVolume")]
+    public float KnockVolume = -6f;
+}

Content.Server/Magic/Events/TeleportSpellEvent.cs

@@ -0,0 +1,10 @@
+using Content.Shared.Actions;
+using Content.Shared.Sound;
+
+namespace Content.Server.Magic.Events;
+
+public sealed class TeleportSpellEvent : WorldTargetActionEvent
+{
+    [DataField("blinkSound")]
+    public SoundSpecifier BlinkSound = new SoundPathSpecifier("/Audio/Magic/blink.ogg");
+}

Content.Server/Magic/Events/WorldSpawnSpellEvent.cs

@@ -0,0 +1,29 @@
+using Content.Shared.Actions;
+using Content.Shared.Storage;
+
+namespace Content.Server.Magic.Events;
+
+public sealed class WorldSpawnSpellEvent : WorldTargetActionEvent
+{
+    // TODO:This class needs combining with InstantSpawnSpellEvent
+
+    /// <summary>
+    /// The list of prototypes this spell will spawn
+    /// </summary>
+    [DataField("prototypes")]
+    public List<EntitySpawnEntry> Contents = new();
+
+    // TODO: This offset is liable for deprecation.
+    /// <summary>
+    /// The offset the prototypes will spawn in on relative to the one prior.
+    /// Set to 0,0 to have them spawn on the same tile.
+    /// </summary>
+    [DataField("offset")]
+    public Vector2 Offset;
+
+    /// <summary>
+    /// Lifetime to set for the entities to self delete
+    /// </summary>
+    [DataField("lifetime")] public float? Lifetime;
+}
+

Content.Server/Magic/MagicSystem.cs

@@ -0,0 +1,317 @@
+using System.Threading;
+using Content.Server.Coordinates.Helpers;
+using Content.Server.Decals;
+using Content.Server.DoAfter;
+using Content.Server.Doors.Components;
+using Content.Server.Magic.Events;
+using Content.Server.Spawners.Components;
+using Content.Shared.Actions;
+using Content.Shared.Actions.ActionTypes;
+using Content.Shared.Doors.Components;
+using Content.Shared.Doors.Systems;
+using Content.Shared.Interaction.Events;
+using Content.Shared.Maps;
+using Content.Shared.Physics;
+using Content.Shared.Storage;
+using Robust.Shared.Audio;
+using Robust.Shared.Map;
+using Robust.Shared.Player;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+
+namespace Content.Server.Magic;
+
+/// <summary>
+/// Handles learning and using spells (actions)
+/// </summary>
+public sealed class MagicSystem : EntitySystem
+{
+    [Dependency] private readonly IMapManager _mapManager = default!;
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    [Dependency] private readonly IRobustRandom _random = default!;
+    [Dependency] private readonly EntityLookupSystem _lookup = default!;
+    [Dependency] private readonly SharedDoorSystem _doorSystem = default!;
+    [Dependency] private readonly SharedActionsSystem _actionsSystem = default!;
+    [Dependency] private readonly DoAfterSystem _doAfter = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<SpellbookComponent, ComponentInit>(OnInit);
+        SubscribeLocalEvent<SpellbookComponent, UseInHandEvent>(OnUse);
+        SubscribeLocalEvent<SpellbookComponent, LearnDoAfterComplete>(OnLearnComplete);
+        SubscribeLocalEvent<SpellbookComponent, LearnDoAfterCancel>(OnLearnCancel);
+
+        SubscribeLocalEvent<InstantSpawnSpellEvent>(OnInstantSpawn);
+        SubscribeLocalEvent<TeleportSpellEvent>(OnTeleportSpell);
+        SubscribeLocalEvent<KnockSpellEvent>(OnKnockSpell);
+        SubscribeLocalEvent<WorldSpawnSpellEvent>(OnWorldSpawn);
+
+    }
+
+    private void OnInit(EntityUid uid, SpellbookComponent component, ComponentInit args)
+    {
+        //Negative charges means the spell can be used without it running out.
+        foreach (var (id, charges) in component.WorldSpells)
+        {
+            var spell = new WorldTargetAction(_prototypeManager.Index<WorldTargetActionPrototype>(id));
+            _actionsSystem.SetCharges(spell, charges < 0 ? null : charges);
+            component.Spells.Add(spell);
+        }
+
+        foreach (var (id, charges) in component.InstantSpells)
+        {
+            var spell = new InstantAction(_prototypeManager.Index<InstantActionPrototype>(id));
+            _actionsSystem.SetCharges(spell, charges < 0 ? null : charges);
+            component.Spells.Add(spell);
+        }
+
+        foreach (var (id, charges) in component.EntitySpells)
+        {
+            var spell = new EntityTargetAction(_prototypeManager.Index<EntityTargetActionPrototype>(id));
+            _actionsSystem.SetCharges(spell, charges < 0 ? null : charges);
+            component.Spells.Add(spell);
+        }
+    }
+
+    private void OnUse(EntityUid uid, SpellbookComponent component, UseInHandEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        AttemptLearn(uid, component, args);
+
+        args.Handled = true;
+    }
+
+    private void AttemptLearn(EntityUid uid, SpellbookComponent component, UseInHandEvent args)
+    {
+        if (component.CancelToken != null) return;
+
+        component.CancelToken = new CancellationTokenSource();
+
+        var doAfterEventArgs = new DoAfterEventArgs(args.User, component.LearnTime, component.CancelToken.Token, uid)
+        {
+            BreakOnTargetMove = true,
+            BreakOnUserMove = true,
+            BreakOnDamage = true,
+            BreakOnStun = true,
+            NeedHand = true, //What, are you going to read with your eyes only??
+            TargetFinishedEvent = new LearnDoAfterComplete(args.User),
+            TargetCancelledEvent = new LearnDoAfterCancel(),
+        };
+
+        _doAfter.DoAfter(doAfterEventArgs);
+    }
+
+    private void OnLearnComplete(EntityUid uid, SpellbookComponent component, LearnDoAfterComplete ev)
+    {
+        component.CancelToken = null;
+        _actionsSystem.AddActions(ev.User, component.Spells, uid);
+    }
+
+    private void OnLearnCancel(EntityUid uid, SpellbookComponent component, LearnDoAfterCancel args)
+    {
+        component.CancelToken = null;
+    }
+
+    #region Spells
+
+    /// <summary>
+    /// Handles the instant action (i.e. on the caster) attempting to spawn an entity.
+    /// </summary>
+    private void OnInstantSpawn(InstantSpawnSpellEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        var transform = Transform(args.Performer);
+
+        foreach (var position in GetSpawnPositions(transform, args.Pos))
+        {
+            var ent = Spawn(args.Prototype, position.SnapToGrid(EntityManager, _mapManager));
+
+            if (args.PreventCollideWithCaster)
+            {
+                var comp = EnsureComp<PreventCollideComponent>(ent);
+                comp.Uid = args.Performer;
+            }
+        }
+
+        args.Handled = true;
+    }
+
+    private List<EntityCoordinates> GetSpawnPositions(TransformComponent casterXform, MagicSpawnData data)
+    {
+        switch (data)
+        {
+            case TargetCasterPos:
+                return new List<EntityCoordinates>(1) {casterXform.Coordinates};
+            case TargetInFront:
+            {
+                // This is shit but you get the idea.
+                var directionPos = casterXform.Coordinates.Offset(casterXform.LocalRotation.ToWorldVec().Normalized);
+
+                if (!_mapManager.TryGetGrid(casterXform.GridID, out var mapGrid))
+                    return new List<EntityCoordinates>();
+
+                if (!directionPos.TryGetTileRef(out var tileReference, EntityManager, _mapManager))
+                    return new List<EntityCoordinates>();
+
+                var tileIndex = tileReference.Value.GridIndices;
+                var coords = mapGrid.GridTileToLocal(tileIndex);
+                EntityCoordinates coordsPlus;
+                EntityCoordinates coordsMinus;
+
+                var dir = casterXform.LocalRotation.GetCardinalDir();
+                switch (dir)
+                {
+                    case Direction.North:
+                    case Direction.South:
+                    {
+                        coordsPlus = mapGrid.GridTileToLocal(tileIndex + (1, 0));
+                        coordsMinus = mapGrid.GridTileToLocal(tileIndex + (-1, 0));
+                        return new List<EntityCoordinates>(3)
+                        {
+                            coords,
+                            coordsPlus,
+                            coordsMinus,
+                        };
+                    }
+                    case Direction.East:
+                    case Direction.West:
+                    {
+                        coordsPlus = mapGrid.GridTileToLocal(tileIndex + (0, 1));
+                        coordsMinus = mapGrid.GridTileToLocal(tileIndex + (0, -1));
+                        return new List<EntityCoordinates>(3)
+                        {
+                            coords,
+                            coordsPlus,
+                            coordsMinus,
+                        };
+                    }
+                }
+
+                return new List<EntityCoordinates>();
+            }
+            default:
+                throw new ArgumentOutOfRangeException();
+        }
+    }
+
+    /// <summary>
+    /// Teleports the user to the clicked location
+    /// </summary>
+    /// <param name="args"></param>
+    private void OnTeleportSpell(TeleportSpellEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        var transform = Transform(args.Performer);
+
+        if (transform.MapID != args.Target.MapId) return;
+
+        transform.WorldPosition = args.Target.Position;
+        transform.AttachToGridOrMap();
+        SoundSystem.Play(Filter.Pvs(args.Target), args.BlinkSound.GetSound());
+        args.Handled = true;
+    }
+
+    /// <summary>
+    /// Opens all doors within range
+    /// </summary>
+    /// <param name="args"></param>
+    private void OnKnockSpell(KnockSpellEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        //Get the position of the player
+        var transform = Transform(args.Performer);
+        var coords = transform.Coordinates;
+
+        SoundSystem.Play(Filter.Pvs(coords), args.KnockSound.GetSound(), AudioParams.Default.WithVolume(args.KnockVolume));
+
+        //Look for doors and don't open them if they're already open.
+        foreach (var entity in _lookup.GetEntitiesInRange(coords, args.Range))
+        {
+            if (TryComp<AirlockComponent>(entity, out var airlock))
+                airlock.BoltsDown = false;
+
+            if (TryComp<DoorComponent>(entity, out var doorComp) && doorComp.State is not DoorState.Open)
+                _doorSystem.StartOpening(doorComp.Owner);
+        }
+
+        args.Handled = true;
+    }
+
+    /// <summary>
+    /// Spawns entity prototypes from a list within range of click.
+    /// </summary>
+    /// <remarks>
+    /// It will offset mobs after the first mob based on the OffsetVector2 property supplied.
+    /// </remarks>
+    /// <param name="args"> The Spawn Spell Event args.</param>
+    private void OnWorldSpawn(WorldSpawnSpellEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        var targetMapCoords = args.Target;
+
+        SpawnSpellHelper(args.Contents, targetMapCoords, args.Lifetime, args.Offset);
+
+        args.Handled = true;
+    }
+
+    /// <summary>
+    /// Loops through a supplied list of entity prototypes and spawns them
+    /// </summary>
+    /// <remarks>
+    /// If an offset of 0, 0 is supplied then the entities will all spawn on the same tile.
+    /// Any other offset will spawn entities starting from the source Map Coordinates and will increment the supplied
+    /// offset
+    /// </remarks>
+    /// <param name="entityEntries"> The list of Entities to spawn in</param>
+    /// <param name="mapCoords"> Map Coordinates where the entities will spawn</param>
+    /// <param name="lifetime"> Check to see if the entities should self delete</param>
+    /// <param name="offsetVector2"> A Vector2 offset that the entities will spawn in</param>
+    private void SpawnSpellHelper(List<EntitySpawnEntry> entityEntries, MapCoordinates mapCoords, float? lifetime, Vector2 offsetVector2)
+    {
+        var getProtos = EntitySpawnCollection.GetSpawns(entityEntries, _random);
+
+        var offsetCoords = mapCoords;
+        foreach (var proto in getProtos)
+        {
+            // TODO: Share this code with instant because they're both doing similar things for positioning.
+            var entity = Spawn(proto, offsetCoords);
+            offsetCoords = offsetCoords.Offset(offsetVector2);
+
+            if (lifetime != null)
+            {
+                var comp = EnsureComp<TimedDespawnComponent>(entity);
+                comp.Lifetime = lifetime.Value;
+            }
+        }
+    }
+
+    #endregion
+
+    #region DoAfterClasses
+
+    private sealed class LearnDoAfterComplete : EntityEventArgs
+    {
+        public readonly EntityUid User;
+
+        public LearnDoAfterComplete(EntityUid uid)
+        {
+            User = uid;
+        }
+    }
+
+    private sealed class LearnDoAfterCancel : EntityEventArgs { }
+
+    #endregion
+}