Simple After-Images Effect

// Enjoy! For context, this code was created in response to https://www.reddit.com/r/gamedev/comments/hge51j/creating_a_flexible_system_for_afterimage_shadow/fw66qxn/

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class AfterImages : MonoBehaviour {

        // Something to notice here: The Request and Image classes in this script are just data containers; They don't have any methods/behavior. Most tutorials would probably teach you the object oriented way of solving this problem where you would add an AfterImage component to your image object prefab and scatter your behavior and fields between that class and this one. Stop that! It only ever leads to madness and it's worse design along almost every dimension (extra ceremony, over-generalized, speculative, harder to understand/modify, slower, more memory, worse cache-coherence). In my version, you'll use just one MonoBehavior (instead of one per image or worse), and all the code is in the same place right where it's used, inline. Simple :)
    public class Request {
        public Transform targetTransform;
        public SpriteRenderer targetSpriteRenderer;
        public float elapsed;
        public float duration;
        public float imageFrequency;
        public float imageFrequencyElapsed;
        public float imageDuration;
    }

    public class Image {
        public Transform transform;
        public SpriteRenderer spriteRenderer;
        public float elapsed;
        public float duration;
    }


    #if UNITY_EDITOR
    [Header("Tests")]
    public Transform targetTransform;
    public SpriteRenderer targetSpriteRenderer;
    public float effectDuration = 10f;
    public float imageFrequency = 0.1f;
    public float imageDuration = 2f;

    [Space(10)]
    public bool pressThisButtonToTest;

    // Here's an easy way to test your code! OnValidate is run every time you change something on this script in the inspector.
    // I wish someone had shown me this when I was starting out in Unity. I used to bind everything to a key press :)
    void OnValidate() {
        if (pressThisButtonToTest) {
            pressThisButtonToTest = false;
            PlayEffect(targetTransform, targetSpriteRenderer, effectDuration, imageFrequency, imageDuration);
        }
    }
    #endif


    // Create a prefab that is just a single GameObject with a SpriteRenderer attached. Assign that prefab to this variable in the inspector.
    // You could also create this simple object in script, i.e. instantiate a new GameObject and then add the SpriteRenderer component, but it's slower and there's no real advantage.
    [Header("References")]
    public GameObject imagePrefab;


    List<Request> requests = new List<Request>(32);
    List<Image> images = new List<Image>(128);


    public void PlayEffect(Transform targetTransform, SpriteRenderer targetSpriteRenderer, float duration, float imageFrequency, float imageDuration) {
        Request request = new Request();
        request.targetTransform = targetTransform;
        request.targetSpriteRenderer = targetSpriteRenderer;
        request.duration = duration;
        request.imageFrequency = imageFrequency;
        request.imageDuration = imageDuration;

        requests.Add(request);
    }

    void Update() {

        // Notice that we're going through the active requests in reverse here since we might be removing some along the way.
        for (int i = requests.Count - 1; i >= 0; i--) {
            requests[i].elapsed += Time.deltaTime;

            if (requests[i].elapsed > requests[i].duration) { // We're done with a request when its duration elapses.
                requests.RemoveAt(i);
                continue;
            }

            if (requests[i].imageFrequencyElapsed == 0f) {
                GameObject imageObject = Instantiate<GameObject>(imagePrefab, transform); // With object pooling, this is where you'd get an inactive image prefab from your pool. You'd instantiate a bunch of images to re-use in awake.
                Image image = new Image();
                image.transform = imageObject.GetComponent<Transform>();
                image.spriteRenderer = imageObject.GetComponent<SpriteRenderer>();
                image.duration = requests[i].imageDuration;

                // Use this new image to "clone" the target of the effect. Exactly which fields you copy over or modify will depend on your game and what you want the effect to look like.
                image.transform.localPosition = requests[i].targetTransform.position;
                image.transform.localScale = requests[i].targetTransform.lossyScale;

                image.spriteRenderer.sprite = requests[i].targetSpriteRenderer.sprite;
                image.spriteRenderer.sortingLayerID = requests[i].targetSpriteRenderer.sortingLayerID;
                image.spriteRenderer.sortingOrder = requests[i].targetSpriteRenderer.sortingOrder - 1;

                Color color = requests[i].targetSpriteRenderer.color;
                color.r *= 0.66f; color.g *= 0.66f; color.b *= 0.66f;  // You can tweak this later, but let's start out by making the clone's color a bit darker.
                image.spriteRenderer.color = color;

                images.Add(image);
            }

            // Every imageFrequency seconds of game time that passes, we'll reset imageFrequencyElapsed to 0f and create a new image next frame.
            // With an imageFrequency of 0.1f, and a request with a duration of 10f, we will end up creating and destroying 100 objects over the lifetime of the effect.
            // If you had a few enemies using this effect at the same time you could be creating and destroying hundreds of these image objects (which is slow and creates garbage). That sounds needlessly wasteful!
            // So, you can see why object pooling to re-use images would be desirable here.
            requests[i].imageFrequencyElapsed += Time.deltaTime;
            if (requests[i].imageFrequencyElapsed >= requests[i].imageFrequency) {
                requests[i].imageFrequencyElapsed = 0f;
            }
        }

        // After we're done going through the active requests, we'll update all the active images in a similar fashion.
        for (int i = images.Count - 1; i >= 0; i--) {
            images[i].elapsed += Time.deltaTime;

            if (images[i].elapsed > images[i].duration) { // This image's lifetime has expired.
                Destroy(images[i].transform.gameObject); // With an object pool, this is where you'd just deactivate the image's game object and save it for later.
                images.RemoveAt(i);
                continue;
            }

            // Here is where you can update your images over their lifetime. Maybe you want your images to fade out over their duration, like so:
            Color color = images[i].spriteRenderer.color;
            color.a = 1f - (images[i].elapsed / images[i].duration);
            images[i].spriteRenderer.color = color;
        }

    }
}