wwdpublic/Content.Shared/Magic/SharedMagicSystem.cs

// SPDX-FileCopyrightText: 2024 AJCM <AJCM@tutanota.com>
// SPDX-FileCopyrightText: 2024 Aiden <aiden@djkraz.com>
// SPDX-FileCopyrightText: 2024 Alzore <140123969+Blackern5000@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Brandon Hu <103440971+Brandon-Huu@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 CaasGit <87243814+CaasGit@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Chief-Engineer <119664036+Chief-Engineer@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Cojoke <83733158+Cojoke-dot@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 DrSmugleaf <10968691+DrSmugleaf@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 DrSmugleaf <DrSmugleaf@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Ed <96445749+TheShuEd@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Emisse <99158783+Emisse@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 EmoGarbage404 <retron404@gmail.com>
// SPDX-FileCopyrightText: 2024 Eoin Mcloughlin <helloworld@eoinrul.es>
// SPDX-FileCopyrightText: 2024 Errant <35878406+Errant-4@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Flareguy <78941145+Flareguy@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Hrosts <35345601+Hrosts@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 IProduceWidgets <107586145+IProduceWidgets@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Ian <ignaz.k@live.de>
// SPDX-FileCopyrightText: 2024 Ilya246 <57039557+Ilya246@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Joel Zimmerman <JoelZimmerman@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 JustCone <141039037+JustCone14@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Killerqu00 <47712032+Killerqu00@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Ko4ergaPunk <62609550+Ko4ergaPunk@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Kukutis96513 <146854220+Kukutis96513@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Leon Friedrich <60421075+ElectroJr@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Lye <128915833+Lyroth001@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 MerrytheManokit <167581110+MerrytheManokit@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Mervill <mervills.email@gmail.com>
// SPDX-FileCopyrightText: 2024 Mr. 27 <45323883+Dutch-VanDerLinde@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 MureixloI <132683811+MureixloI@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 NakataRin <45946146+NakataRin@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Nemanja <98561806+EmoGarbage404@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 OrangeMoronage9622 <whyteterry0092@gmail.com>
// SPDX-FileCopyrightText: 2024 PJBot <pieterjan.briers+bot@gmail.com>
// SPDX-FileCopyrightText: 2024 Pieter-Jan Briers <pieterjan.briers+git@gmail.com>
// SPDX-FileCopyrightText: 2024 Piras314 <p1r4s@proton.me>
// SPDX-FileCopyrightText: 2024 Plykiya <58439124+Plykiya@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Preston Smith <92108534+thetolbean@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Psychpsyo <60073468+Psychpsyo@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Repo <47093363+Titian3@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 RiceMar1244 <138547931+RiceMar1244@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 ShadowCommander <10494922+ShadowCommander@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Simon <63975668+Simyon264@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 SlamBamActionman <83650252+SlamBamActionman@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Stalen <33173619+stalengd@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 TakoDragon <69509841+BackeTako@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Thomas <87614336+Aeshus@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 TsjipTsjip <19798667+TsjipTsjip@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Ubaser <134914314+UbaserB@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 Unkn0wn_Gh0st <shadowstalkermll@gmail.com>
// SPDX-FileCopyrightText: 2024 Vasilis <vasilis@pikachu.systems>
// SPDX-FileCopyrightText: 2024 Vigers Ray <60344369+VigersRay@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 beck-thompson <107373427+beck-thompson@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 deathride58 <deathride58@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 deltanedas <39013340+deltanedas@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 deltanedas <@deltanedas:kde.org>
// SPDX-FileCopyrightText: 2024 dffdff2423 <dffdff2423@gmail.com>
// SPDX-FileCopyrightText: 2024 eoineoineoin <github@eoinrul.es>
// SPDX-FileCopyrightText: 2024 foboscheshir <156405958+foboscheshir@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 lzk <124214523+lzk228@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 metalgearsloth <31366439+metalgearsloth@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 metalgearsloth <comedian_vs_clown@hotmail.com>
// SPDX-FileCopyrightText: 2024 nikthechampiongr <32041239+nikthechampiongr@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 plykiya <plykiya@protonmail.com>
// SPDX-FileCopyrightText: 2024 saintmuntzer <47153094+saintmuntzer@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 shamp <140359015+shampunj@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 slarticodefast <161409025+slarticodefast@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 strO0pwafel <153459934+strO0pwafel@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 stroopwafel <j.o.luijkx@student.tudelft.nl>
// SPDX-FileCopyrightText: 2024 themias <89101928+themias@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 to4no_fix <156101927+chavonadelal@users.noreply.github.com>
// SPDX-FileCopyrightText: 2024 voidnull000 <18663194+voidnull000@users.noreply.github.com>
// SPDX-FileCopyrightText: 2025 ActiveMammmoth <140334666+ActiveMammmoth@users.noreply.github.com>
// SPDX-FileCopyrightText: 2025 ActiveMammmoth <kmcsmooth@gmail.com>
// SPDX-FileCopyrightText: 2025 Aiden <28298836+Aidenkrz@users.noreply.github.com>
// SPDX-FileCopyrightText: 2025 Aviu00 <93730715+Aviu00@users.noreply.github.com>
// SPDX-FileCopyrightText: 2025 Misandry <mary@thughunt.ing>
// SPDX-FileCopyrightText: 2025 gus <august.eymann@gmail.com>
// SPDX-FileCopyrightText: 2025 keronshb <54602815+keronshb@users.noreply.github.com>
//
// SPDX-License-Identifier: AGPL-3.0-or-later

using System.Linq;
using System.Numerics;
using Content.Shared.Changeling;
using Content.Shared._Shitcode.Wizard;
using Content.Shared._Shitcode.Wizard.BindSoul;
using Content.Shared._Shitcode.Wizard.Chuuni;
using Content.Shared._Shitcode.Wizard.FadingTimedDespawn;
using Content.Shared._Shitmed.Targeting;
using Content.Shared.Actions;
using Content.Shared.Body.Components;
using Content.Shared.Body.Systems;
using Content.Shared.Coordinates.Helpers;
using Content.Shared.Damage;
using Content.Shared.Doors.Components;
using Content.Shared.Doors.Systems;
using Content.Shared.FixedPoint;
using Content.Shared.Ghost;
using Content.Shared.Gibbing.Events;
using Content.Shared.Hands.Components;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Interaction;
using Content.Shared.Inventory;
using Content.Shared.Lock;
using Content.Shared.Magic.Components;
using Content.Shared.Magic.Events;
using Content.Shared.Maps;
using Content.Shared.Mind;
using Content.Shared.Mobs.Systems;
using Content.Shared.NPC.Components;
using Content.Shared.NPC.Prototypes;
using Content.Shared.NPC.Systems;
using Content.Shared.Physics;
using Content.Shared.Popups;
using Content.Shared.Revolutionary.Components;
using Content.Shared.Speech.Muting;
using Content.Shared.Storage;
using Content.Shared.Stunnable;
using Content.Shared.Tag;
using Content.Shared.Weapons.Ranged.Components;
using Content.Shared.Weapons.Ranged.Systems;
using Content.Shared.Zombies;
using Robust.Shared.Audio.Systems;
using Robust.Shared.Map;
using Robust.Shared.Map.Components;
using Robust.Shared.Network;
using Robust.Shared.Physics.Systems;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
using Robust.Shared.Serialization.Manager;
using Robust.Shared.Spawners;
using Robust.Shared.Timing;

namespace Content.Shared.Magic;

/// <summary>
/// Handles learning and using spells (actions)
/// </summary>
public abstract class SharedMagicSystem : EntitySystem
{
    [Dependency] private readonly IGameTiming _timing = default!; // Goobstation
    [Dependency] private readonly ISerializationManager _seriMan = default!;
    [Dependency] private readonly IComponentFactory _compFact = default!;
    [Dependency] private readonly IMapManager _mapManager = default!;
    [Dependency] private readonly SharedMapSystem _mapSystem = default!;
    [Dependency] private readonly IRobustRandom _random = default!;
    [Dependency] private readonly SharedGunSystem _gunSystem = default!;
    [Dependency] private readonly SharedPhysicsSystem _physics = default!;
    [Dependency] private readonly SharedTransformSystem _transform = default!;
    [Dependency] private readonly INetManager _net = default!;
    [Dependency] private readonly SharedBodySystem _body = default!;
    [Dependency] private readonly EntityLookupSystem _lookup = default!;
    [Dependency] private readonly SharedDoorSystem _door = default!;
    [Dependency] private readonly InventorySystem _inventory = default!;
    [Dependency] private readonly SharedPopupSystem _popup = default!;
    [Dependency] private readonly SharedInteractionSystem _interaction = default!;
    [Dependency] private readonly LockSystem _lock = default!;
    [Dependency] private readonly SharedHandsSystem _hands = default!;
    [Dependency] private readonly TagSystem _tag = default!;
    [Dependency] private readonly MobStateSystem _mobState = default!;
    [Dependency] private readonly SharedAudioSystem _audio = default!;
    [Dependency] private readonly SharedMindSystem _mind = default!;
    [Dependency] private readonly SharedStunSystem _stun = default!;
    [Dependency] private readonly DamageableSystem _damageable = default!; // Goobstation
    [Dependency] private readonly NpcFactionSystem _faction = default!; // Goobstation

    public override void Initialize()
    {
        base.Initialize();
        SubscribeLocalEvent<MagicComponent, BeforeCastSpellEvent>(OnBeforeCastSpell);

        SubscribeLocalEvent<InstantSpawnSpellEvent>(OnInstantSpawn);
        SubscribeLocalEvent<TeleportSpellEvent>(OnTeleportSpell);
        SubscribeLocalEvent<WorldSpawnSpellEvent>(OnWorldSpawn);
        SubscribeLocalEvent<ProjectileSpellEvent>(OnProjectileSpell);
        SubscribeLocalEvent<ChangeComponentsSpellEvent>(OnChangeComponentsSpell);
        SubscribeLocalEvent<SmiteSpellEvent>(OnSmiteSpell);
        SubscribeLocalEvent<KnockSpellEvent>(OnKnockSpell);
        SubscribeLocalEvent<ChargeSpellEvent>(OnChargeSpell);
        SubscribeLocalEvent<RandomGlobalSpawnSpellEvent>(OnRandomGlobalSpawnSpell);
        SubscribeLocalEvent<MindSwapSpellEvent>(OnMindSwapSpell);

        // Spell wishlist
        //  A wishlish of spells that I'd like to implement or planning on implementing in a future PR

        // TODO: InstantDoAfterSpell and WorldDoafterSpell
        //  Both would be an action that take in an event, that passes an event to trigger once the doafter is done
        //  This would be three events:
        //    1 - Event that triggers from the action that starts the doafter
        //    2 - The doafter event itself, which passes the event with it
        //    3 - The event to trigger once the do-after finishes

        // TODO: Inanimate objects to life ECS
        //  AI sentience

        // TODO: Flesh2Stone
        //   Entity Target spell
        //   Synergy with Inanimate object to life (detects player and allows player to move around)

        // TODO: Lightning Spell
        // Should just fire lightning, try to prevent arc back to caster

        // TODO: Magic Missile (homing projectile ecs)
        //   Instant action, target any player (except self) on screen

        // TODO: Random projectile ECS for magic-carp, wand of magic

        // TODO: Recall Spell
        //  mark any item in hand to recall
        //    ItemRecallComponent
        //    Event adds the component if it doesn't exist and the performer isn't stored in the comp
        //    2nd firing of the event checks to see if the recall comp has this uid, and if it does it calls it
        //  if no free hands, summon at feet
        //  if item deleted, clear stored item

        // TODO: Jaunt (should be its own ECS)
        // Instant action
        //   When clicked, disappear/reappear (goes to paused map)
        //   option to restrict to tiles
        //   option for requiring entry/exit (blood jaunt)
        //   speed option

        // TODO: Summon Events
        //  List of wizard events to add into the event pool that frequently activate
        //  floor is lava
        //  change places
        //  ECS that when triggered, will periodically trigger a random GameRule
        //  Would need a controller/controller entity?

        // TODO: Summon Guns
        //  Summon a random gun at peoples feet
        //    Get every alive player (not in cryo, not a simplemob)
        //  TODO: After Antag Rework - Rare chance of giving gun collector status to people

        // TODO: Summon Magic
        //  Summon a random magic wand at peoples feet
        //    Get every alive player (not in cryo, not a simplemob)
        //  TODO: After Antag Rework - Rare chance of giving magic collector status to people

        // TODO: Bottle of Blood
        //  Summons Slaughter Demon
        //  TODO: Slaughter Demon
        //    Also see Jaunt

        // TODO: Field Spells
        //  Should be able to specify a grid of tiles (3x3 for example) that it effects
        //  Timed despawn - so it doesn't last forever
        //  Ignore caster - for spells that shouldn't effect the caster (ie if timestop should effect the caster)

        // TODO: Touch toggle spell
        //  1 - When toggled on, show in hand
        //  2 - Block hand when toggled on
        //      - Require free hand
        //  3 - use spell event when toggled & click
    }

    private void OnBeforeCastSpell(Entity<MagicComponent> ent, ref BeforeCastSpellEvent args)
    {
        var comp = ent.Comp;
        var hasReqs = true;

        // Goobstation start
        var requiresSpeech = comp.RequiresSpeech;
        var flags = SlotFlags.OUTERCLOTHING | SlotFlags.HEAD;
        var requiredSlots = 2;
        if (_inventory.TryGetSlotEntity(args.Performer, "eyes", out var eyepatch) &&
            HasComp<ChuuniEyepatchComponent>(eyepatch.Value))
        {
            requiresSpeech = true;
            flags = SlotFlags.OUTERCLOTHING;
            requiredSlots = 1;
        }

        var slots = 0;
        // Goobstation end

        if (comp.RequiresClothes)
        {
            if (!TryComp(args.Performer, out InventoryComponent? inventory)) // Goob edit
                hasReqs = false;
            else
            {
                var enumerator = _inventory.GetSlotEnumerator((args.Performer, inventory), flags); // Goob edit
                while (enumerator.MoveNext(out var containerSlot))
                {
                    slots++; // Goobstation

                    if (containerSlot.ContainedEntity is { } item)
                        hasReqs = HasComp<WizardClothesComponent>(item);
                    else
                        hasReqs = false;

                    if (!hasReqs)
                        break;
                }
            }

            if (slots < requiredSlots) // Goobstation
                hasReqs = false;
        }

        if (!hasReqs) // Goobstation
        {
            _popup.PopupClient(Loc.GetString("spell-requirements-failed-clothes"), args.Performer, args.Performer);
            args.Cancelled = true;
            return;
        }

        if (requiresSpeech && HasComp<MutedComponent>(args.Performer)) // Goob edit
            hasReqs = false;

        if (hasReqs)
            return;

        args.Cancelled = true;
        _popup.PopupClient(Loc.GetString("spell-requirements-failed-speech"), args.Performer, args.Performer); // Goob edit

        // TODO: Pre-cast do after, either here or in SharedActionsSystem
    }

    public bool PassesSpellPrerequisites(EntityUid spell, EntityUid performer) // Goob edit
    {
        var ev = new BeforeCastSpellEvent(performer);
        RaiseLocalEvent(spell, ref ev);
        return !ev.Cancelled;
    }

    #region Spells
    #region Instant Spawn 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 || !PassesSpellPrerequisites(args.Action, args.Performer))
            return;

        var transform = Transform(args.Performer);

        foreach (var position in GetInstantSpawnPositions(transform, args.PosData))
        {
            SpawnSpellHelper(args.Prototype, position, args.Performer, preventCollide: args.PreventCollideWithCaster);
        }

        Speak(args);
        args.Handled = true;
    }

        /// <summary>
    ///     Gets spawn positions listed on <see cref="InstantSpawnSpellEvent"/>
    /// </summary>
    /// <exception cref="ArgumentOutOfRangeException"></exception>
    private List<EntityCoordinates> GetInstantSpawnPositions(TransformComponent casterXform, MagicInstantSpawnData data)
    {
        switch (data)
        {
            case TargetCasterPos:
                return new List<EntityCoordinates>(1) {casterXform.Coordinates};
            case TargetInFrontSingle:
            {
                var directionPos = casterXform.Coordinates.Offset(casterXform.LocalRotation.ToWorldVec().Normalized());

                if (!TryComp<MapGridComponent>(casterXform.GridUid, out var mapGrid))
                    return new List<EntityCoordinates>();
                if (!directionPos.TryGetTileRef(out var tileReference, EntityManager, _mapManager))
                    return new List<EntityCoordinates>();

                var tileIndex = tileReference.Value.GridIndices;
                return new List<EntityCoordinates>(1) { _mapSystem.GridTileToLocal(casterXform.GridUid.Value, mapGrid, tileIndex) };
            }
            case TargetInFront:
            {
                var directionPos = casterXform.Coordinates.Offset(casterXform.LocalRotation.ToWorldVec().Normalized());

                if (!TryComp<MapGridComponent>(casterXform.GridUid, 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 = _mapSystem.GridTileToLocal(casterXform.GridUid.Value, mapGrid, tileIndex);
                EntityCoordinates coordsPlus;
                EntityCoordinates coordsMinus;

                var dir = casterXform.LocalRotation.GetCardinalDir();
                switch (dir)
                {
                    case Direction.North:
                    case Direction.South:
                    {
                        coordsPlus = _mapSystem.GridTileToLocal(casterXform.GridUid.Value, mapGrid, tileIndex + (1, 0));
                        coordsMinus = _mapSystem.GridTileToLocal(casterXform.GridUid.Value, mapGrid, tileIndex + (-1, 0));
                        return new List<EntityCoordinates>(3)
                        {
                            coords,
                            coordsPlus,
                            coordsMinus,
                        };
                    }
                    case Direction.East:
                    case Direction.West:
                    {
                        coordsPlus = _mapSystem.GridTileToLocal(casterXform.GridUid.Value, mapGrid, tileIndex + (0, 1));
                        coordsMinus = _mapSystem.GridTileToLocal(casterXform.GridUid.Value, mapGrid, tileIndex + (0, -1));
                        return new List<EntityCoordinates>(3)
                        {
                            coords,
                            coordsPlus,
                            coordsMinus,
                        };
                    }
                }

                return new List<EntityCoordinates>();
            }
            default:
                throw new ArgumentOutOfRangeException();
        }
    }
    // End Instant Spawn Spells
    #endregion
    #region World Spawn Spells
    /// <summary>
    /// Spawns entities from a list within range of click.
    /// </summary>
    /// <remarks>
    /// It will offset entities after the first entity based on the OffsetVector2.
    /// </remarks>
    /// <param name="args"> The Spawn Spell Event args.</param>
    private void OnWorldSpawn(WorldSpawnSpellEvent args)
    {
        if (args.Handled || !PassesSpellPrerequisites(args.Action, args.Performer))
            return;

        var targetMapCoords = args.Target;

        WorldSpawnSpellHelper(args.Prototypes, targetMapCoords, args.Performer, args.Lifetime, args.Offset);
        Speak(args);
        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="entityCoords"> 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 WorldSpawnSpellHelper(List<EntitySpawnEntry> entityEntries, EntityCoordinates entityCoords, EntityUid performer, float? lifetime, Vector2 offsetVector2)
    {
        var getProtos = EntitySpawnCollection.GetSpawns(entityEntries, _random);

        var offsetCoords = entityCoords;
        foreach (var proto in getProtos)
        {
            SpawnSpellHelper(proto, offsetCoords, performer, lifetime);
            offsetCoords = offsetCoords.Offset(offsetVector2);
        }
    }
    // End World Spawn Spells
    #endregion
    #region Projectile Spells
    private void OnProjectileSpell(ProjectileSpellEvent ev)
    {
        if (ev.Handled || !PassesSpellPrerequisites(ev.Action, ev.Performer)) // Goob edit
            return;

        if (ev.Coords == null) // Goob edit
            return;

        ev.Handled = true;
        Speak(ev);

        if (_net.IsClient) // Goobstation
            return;

        var xform = Transform(ev.Performer);
        var fromCoords = xform.Coordinates;
        var toCoords = ev.Coords.Value; // Goob edit

        // If applicable, this ensures the projectile is parented to grid on spawn, instead of the map.
        var fromMap = fromCoords.ToMap(EntityManager, _transform);
        var spawnCoords = _mapManager.TryFindGridAt(fromMap, out var gridUid, out _)
            ? fromCoords.WithEntityId(gridUid, EntityManager)
            : new(_mapManager.GetMapEntityId(fromMap.MapId), fromMap.Position);

        var userVelocity = _physics.GetMapLinearVelocity(spawnCoords); // Goob edit

        var ent = Spawn(ev.Prototype, spawnCoords);
        var direction = toCoords.ToMapPos(EntityManager, _transform) -
                        spawnCoords.ToMapPos(EntityManager, _transform);
        _gunSystem.ShootProjectile(ent, direction, userVelocity, ev.Performer, ev.Performer);

        if (ev.Entity != null) // Goobstation
            _gunSystem.SetTarget(ent, ev.Entity.Value, out _);
    }
    // End Projectile Spells
    #endregion
    #region Change Component Spells
    // staves.yml ActionRGB light
    private void OnChangeComponentsSpell(ChangeComponentsSpellEvent ev)
    {
        if (ev.Handled || !PassesSpellPrerequisites(ev.Action, ev.Performer))
            return;

        ev.Handled = true;
        if (ev.DoSpeech)
            Speak(ev);

        RemoveComponents(ev.Target, ev.ToRemove);
        AddComponents(ev.Target, ev.ToAdd);
    }
    // End Change Component Spells
    #endregion
    #region Teleport Spells
    // TODO: Rename to teleport clicked spell?
    /// <summary>
    /// Teleports the user to the clicked location
    /// </summary>
    /// <param name="args"></param>
    private void OnTeleportSpell(TeleportSpellEvent args)
    {
        if (args.Handled || !PassesSpellPrerequisites(args.Action, args.Performer))
            return;

        var transform = Transform(args.Performer);

        if (transform.MapID != args.Target.GetMapId(EntityManager) || !_interaction.InRangeUnobstructed(args.Performer, args.Target, range: 1000F, collisionMask: CollisionGroup.Opaque, popup: true))
            return;

        _transform.SetCoordinates(args.Performer, args.Target);
        _transform.AttachToGridOrMap(args.Performer, transform);
        Speak(args);
        args.Handled = true;
    }
    // End Teleport Spells
    #endregion
    #region Spell Helpers
    private void SpawnSpellHelper(string? proto, EntityCoordinates position, EntityUid performer, float? lifetime = null, bool preventCollide = false)
    {
        if (!_net.IsServer)
            return;

        var ent = Spawn(proto, position.SnapToGrid(EntityManager, _mapManager));

        if (lifetime != null)
        {
            var comp = EnsureComp<TimedDespawnComponent>(ent);
            comp.Lifetime = lifetime.Value;
        }

        if (preventCollide)
        {
            var comp = EnsureComp<PreventCollideComponent>(ent);
            comp.Uid = performer;
        }
    }

    private void AddComponents(EntityUid target, ComponentRegistry comps)
    {
        foreach (var (name, data) in comps)
        {
            if (HasComp(target, data.Component.GetType()))
                continue;

            var component = (Component)_compFact.GetComponent(name);
            var temp = (object)component;
            _seriMan.CopyTo(data.Component, ref temp);
            EntityManager.AddComponent(target, (Component)temp!);
        }
    }

    private void RemoveComponents(EntityUid target, HashSet<string> comps)
    {
        foreach (var toRemove in comps)
        {
            if (_compFact.TryGetRegistration(toRemove, out var registration))
                RemComp(target, registration.Type);
        }
    }
    // End Spell Helpers
    #endregion
    #region Smite Spells
    private void OnSmiteSpell(SmiteSpellEvent ev)
    {
        if (ev.Handled || !PassesSpellPrerequisites(ev.Action, ev.Performer))
            return;

        ev.Handled = true;
        Speak(ev);

        var direction = _transform.GetMapCoordinates(ev.Target, Transform(ev.Target)).Position - _transform.GetMapCoordinates(ev.Performer, Transform(ev.Performer)).Position;
        var impulseVector = direction * 10000;

        _physics.ApplyLinearImpulse(ev.Target, impulseVector);

        if (!TryComp<BodyComponent>(ev.Target, out var body))
            return;

        if (_timing.IsFirstTimePredicted) // Goobstation
            _body.GibBody(ev.Target, true, body, splatModifier: 10f, contents: GibContentsOption.Skip); // Goob edit
    }
    // End Smite Spells
    #endregion
    #region Knock Spells
    /// <summary>
    /// Opens all doors and locks within range
    /// </summary>
    /// <param name="args"></param>
    private void OnKnockSpell(KnockSpellEvent args)
    {
        if (args.Handled || !PassesSpellPrerequisites(args.Action, args.Performer))
            return;

        args.Handled = true;
        Speak(args);

        var transform = Transform(args.Performer);

        // Look for doors and lockers, and don't open/unlock them if they're already opened/unlocked.
        foreach (var target in _lookup.GetEntitiesInRange(_transform.GetMapCoordinates(args.Performer, transform), args.Range, flags: LookupFlags.Dynamic | LookupFlags.Static | LookupFlags.Approximate)) // Goob edit
        {
            // Goob edit
            // if (!_interaction.InRangeUnobstructed(args.Performer, target, range: 0, collisionMask: CollisionGroup.Opaque))
            //    continue;

            if (TryComp<DoorBoltComponent>(target, out var doorBoltComp) && doorBoltComp.BoltsDown)
                _door.SetBoltsDown((target, doorBoltComp), false, predicted: true);

            if (TryComp<DoorComponent>(target, out var doorComp) && doorComp.State is not DoorState.Open)
                _door.StartOpening(target);

            if (TryComp<LockComponent>(target, out var lockComp) && lockComp.Locked)
                _lock.Unlock(target, args.Performer, lockComp);
        }
    }
    // End Knock Spells
    #endregion
    #region Charge Spells
    // TODO: Future support to charge other items
    private void OnChargeSpell(ChargeSpellEvent ev)
    {
        if (ev.Handled || !PassesSpellPrerequisites(ev.Action, ev.Performer) || !TryComp<HandsComponent>(ev.Performer, out var handsComp))
            return;

        EntityUid? wand = null;
        foreach (var item in _hands.EnumerateHeld(ev.Performer, handsComp))
        {
            if (!_tag.HasTag(item, ev.WandTag))
                continue;

            wand = item;
        }

        ev.Handled = true;
        Speak(ev);

        if (wand == null || !TryComp<BasicEntityAmmoProviderComponent>(wand, out var basicAmmoComp) || basicAmmoComp.Count == null)
            return;

        _gunSystem.UpdateBasicEntityAmmoCount(wand.Value, basicAmmoComp.Count.Value + ev.Charge, basicAmmoComp);
    }
    // End Charge Spells
    #endregion
    #region Global Spells

    private void OnRandomGlobalSpawnSpell(RandomGlobalSpawnSpellEvent ev)
    {
        if (!_net.IsServer || ev.Handled || !PassesSpellPrerequisites(ev.Action, ev.Performer) || ev.Spawns is not { } spawns)
            return;

        ev.Handled = true;
        Speak(ev);

        var allHumans = _mind.GetAliveHumans();

        foreach (var human in allHumans)
        {
            if (!human.Comp.OwnedEntity.HasValue)
                continue;

            var ent = human.Comp.OwnedEntity.Value;

            var mapCoords = _transform.GetMapCoordinates(ent);
            foreach (var spawn in EntitySpawnCollection.GetSpawns(spawns, _random))
            {
                var spawned = Spawn(spawn, mapCoords);
                _hands.PickupOrDrop(ent, spawned);
            }
        }

        _audio.PlayGlobal(ev.Sound, ev.Performer);
    }

    #endregion
    #region Mindswap Spells

    private void OnMindSwapSpell(MindSwapSpellEvent ev)
    {
        if (ev.Handled || !PassesSpellPrerequisites(ev.Action, ev.Performer))
            return;

        // Goobstation start
        if (_mobState.IsIncapacitated(ev.Target) || HasComp<ZombieComponent>(ev.Target))
        {
            _popup.PopupClient(Loc.GetString("spell-fail-mindswap-dead"), ev.Performer, ev.Performer);
            return;
        }

        List<(Type, string)> blockers = new()
        {
            (typeof(ChangelingComponent), "changeling"),
            // You should be able to mindswap with heretics,
            // but all of their data and abilities are not tied to their mind, I'm not making this work.
            // (typeof(HereticComponent), "heretic"), TODO: Uncomment, when heretic will be ported
            // (typeof(GhoulComponent), "ghoul"), TODO: Uncomment, when heretic will be ported
            // Mindswapping with aghost real.
            (typeof(GhostComponent), "ghost"),
            (typeof(SpectralComponent), "ghost"),
            (typeof(TimedDespawnComponent), "temporary"),
            (typeof(FadingTimedDespawnComponent), "temporary"),
        };

        if (blockers.Any(x => CheckMindswapBlocker(x.Item1, x.Item2)))
            return;
        // Goobstation end

        ev.Handled = true;
        Speak(ev);

        // Need performer mind, but target mind is unnecessary, such as taking over a NPC
        // Need to get target mind before putting performer mind into their body if they have one
        // Thus, assign bool before first transfer, then check afterwards

        if (!_mind.TryGetMind(ev.Performer, out var perMind, out var perMindComp))
            return;

        var tarHasMind = _mind.TryGetMind(ev.Target, out var tarMind, out var tarMindComp);

        _tag.AddTag(ev.Performer, SharedBindSoulSystem.IgnoreBindSoulTag); // Goobstation
        _tag.AddTag(ev.Target, SharedBindSoulSystem.IgnoreBindSoulTag); // Goobstation

        _mind.TransferTo(perMind, ev.Target);

        if (tarHasMind)
        {
            _mind.TransferTo(tarMind, ev.Performer);
        }

        // Goobstation start
        List<Type> components = new()
        {
            typeof(RevolutionaryComponent),
            typeof(HeadRevolutionaryComponent),
            typeof(WizardComponent),
            typeof(ApprenticeComponent),
        };

        foreach (var component in components)
        {
            TransferComponent(component, ev.Performer, ev.Target);
        }

        TransferFactions();

        if (_net.IsServer)
        {
            _audio.PlayEntity(ev.Sound, ev.Target, ev.Target);
            _audio.PlayEntity(ev.Sound, ev.Performer, ev.Performer);
        }
        // Goobstation end

        _tag.RemoveTag(ev.Performer, SharedBindSoulSystem.IgnoreBindSoulTag); // Goobstation
        _tag.RemoveTag(ev.Target, SharedBindSoulSystem.IgnoreBindSoulTag); // Goobstation

        _stun.KnockdownOrStun(ev.Target, ev.TargetStunDuration, true); // Goob edit
        _stun.KnockdownOrStun(ev.Performer, ev.PerformerStunDuration, true); // Goob edit

        // Goobstation start
        return;

        void TransferFactions()
        {
            TryComp(ev.Performer, out NpcFactionMemberComponent? performerFaction);
            TryComp(ev.Target, out NpcFactionMemberComponent? targetFaction);

            if (performerFaction == null && targetFaction == null)
                return;

            var performerHadFaction = true;
            var targetHadFaction = true;

            if (performerFaction == null)
            {
                performerFaction = AddComp<NpcFactionMemberComponent>(ev.Performer);
                performerHadFaction = false;
            }

            if (targetFaction == null)
            {
                targetFaction = AddComp<NpcFactionMemberComponent>(ev.Target);
                targetHadFaction = false;
            }

            List<ProtoId<NpcFactionPrototype>> factionsToTransfer = new()
            {
                "Wizard",
            };

            ProtoId<NpcFactionPrototype> fallbackFaction = "NanoTrasen";

            var performerFactions = new HashSet<ProtoId<NpcFactionPrototype>>();
            var targetFactions = new HashSet<ProtoId<NpcFactionPrototype>>();

            foreach (var faction in FilterFactions(performerFaction.Factions))
            {
                performerFactions.Add(faction);
            }

            foreach (var faction in FilterFactions(targetFaction.Factions))
            {
                targetFactions.Add(faction);
            }

            Entity<NpcFactionMemberComponent?> targetFactionEnt = (ev.Target, targetFaction);
            foreach (var faction in targetFactions)
            {
                _faction.RemoveFaction(targetFactionEnt, faction, false);
            }

            Entity<NpcFactionMemberComponent?> performerFactionEnt = (ev.Performer, performerFaction);
            foreach (var faction in performerFactions)
            {
                _faction.RemoveFaction(performerFactionEnt, faction, false);
            }

            if (performerHadFaction)
                _faction.AddFactions(targetFactionEnt, performerFactions);

            if (targetHadFaction)
                _faction.AddFactions(performerFactionEnt, targetFactions);

            if (targetFaction.Factions.Count == 0)
                _faction.AddFaction(targetFactionEnt, fallbackFaction);

            if (performerFaction.Factions.Count == 0)
                _faction.AddFaction(performerFactionEnt, fallbackFaction);
            return;

            IEnumerable<ProtoId<NpcFactionPrototype>> FilterFactions(HashSet<ProtoId<NpcFactionPrototype>> factions)
            {
                return factions.Where(x => factionsToTransfer.Contains(x));
            }
        }

        bool CheckMindswapBlocker(Type type, string message)
        {
            if (!HasComp(ev.Target, type))
                return false;

            _popup.PopupClient(Loc.GetString($"spell-fail-mindswap-{message}"), ev.Performer, ev.Performer);
            return true;
        }
        // Goobstation end
    }

    private void TransferComponent(Type type, EntityUid a, EntityUid b)
    {
        var aHasComp = HasComp(a, type);
        var bHasComp = HasComp(b, type);

        if (aHasComp && bHasComp)
            return;

        var comp = _compFact.GetComponent(type);
        if (aHasComp)
        {
            AddComp(b, comp);
            RemCompDeferred(a, type);
        }
        else if (bHasComp)
        {
            AddComp(a, comp);
            RemCompDeferred(b, type);
        }
    }

    #endregion
    // End Spells
    #endregion

    // When any spell is cast it will raise this as an event, so then it can be played in server or something. At least until chat gets moved to shared
    // TODO: Temp until chat is in shared
    public void Speak(BaseActionEvent args) // Goob edit
    {
        // Goob edit start
        var speech = string.Empty;

        if (args is ISpeakSpell speak && !string.IsNullOrWhiteSpace(speak.Speech))
            speech = speak.Speech;

        if (TryComp(args.Action, out MagicComponent? magic))
        {
            var invocationEv = new GetSpellInvocationEvent(magic.School, args.Performer);
            RaiseLocalEvent(args.Performer, invocationEv);
            if (invocationEv.Invocation.HasValue)
                speech = invocationEv.Invocation;
            if (invocationEv.ToHeal.GetTotal() > FixedPoint2.Zero)
            {
                _damageable.TryChangeDamage(args.Performer,
                    -invocationEv.ToHeal,
                    true,
                    false,
                    canSever: false,
                    targetPart: TargetBodyPart.All);
            }
        }

        if (string.IsNullOrEmpty(speech))
            return;

        var ev = new SpeakSpellEvent(args.Performer, speech);
        // Goob edit end
        RaiseLocalEvent(ref ev);
    }
}