mob/NPC
    icon_state = "NPC"

    Click()
        // Begin attacking each other
        usr.Attack_Loop(src)
        src.Attack_Loop(usr)

mob
    icon = 'Icons.dmi'
    icon_state = "Player"

    var
        Strength = 50
        Defence = 10
        Health = 100
        HealthCap = 100
        Attack_Delay = 15

        attacking = 0 // Set to zero at any time to stop attacking

    proc
        Attack_Loop(mob/M)
            if(attacking) return
            else          attacking = 1
            spawn()
                while(attacking && (M in oview(1,src)) && !M.invisibility)
                    var/Damage = (Strength + rand(0,3)) - (M.Defence + rand(0,3))

                    if(Damage > 0)
                        world << "[M.name] was hit for [Damage] damage!"

                        if(!M.Take_Damage(Damage))
                            world << "[M.name] was killed by [name]!\n"

                    sleep(Attack_Delay)

                attacking = 0

        Take_Damage(Amount)
            Health -= Amount
            if(Health <= 0)
                spawn() Die()
                return 0
            else
                return 1

        Die()
            attacking = 0
            Move(locate(1,1,1))
            Health = HealthCap

    Move()
        attacking = 0
        ..()

mob/NPC
    var/respawnTime = 100

    Die()
        attacking = 0

        density = 0
        invisibility = 101
        Health = HealthCap

        Move(initial(loc))
        sleep(respawnTime)

        density = 1
        invisibility = 0

>             if(attacking) return
>             else          attacking = 1
>

mob/proc

    Attack(mob/Target)
        while(Target in oview(1,src))
            if(!Attacking && !Target.NPC)
                var damage = (Strength + rand(0,3)) - (Target.Defence + rand(0,3))
                if(damage <=0)
                    damage = 0
                    world<< "[Target] was hit for [damage] damage!"
                    Attacking = 1
                    sleep(30)
                    Attacking = 0
                    Target.Attacking = 0
                    Target.Attack(src)
                else
                    world<< "[Target] was hit for [damage] damage!"
                    Target.Health -= damage
                    Attacking = 1
                    sleep(30)
                    Attacking = 0
                    Target.Attacking = 0
                    Target.Attack(src)
            else
                return

//This #define (preprocessor definition) should be in another file like !defines.dm because order matters in preprocessing, so we want it to be in a file that is alphabetically before all of our other files.
#define TICK_LAG world.tick_lag //Replace world.tick_lag with whatever you set world.tick_lag to.  If you use world.fps instead, this is 10/world.fps, but calculate it yourself and put it there.  Assuming your tick_lag is not dynamic.  This is here because you're going to probably be using this later down the line, and using a preprocessor definition is generally better than using world.tick_lag.

mob/proc
    Attack(mob/Target)
        //If you don't mind the check being infrequent to save CPU, you can set wait to 1 or higher.
        //Since wait and complete should be constants, you could just place them right in or make preprocessor defines for them (like TICK_LAG)
        //But for the sake of simplicity and since this seems to only be used for one function that won't be called super frequently, we'll make them local variables.
        var wait = TICK_LAG //Check every frame (or however long you want)...
        var complete = 30 //3 seconds to complete the first part and switch over to Target.Attack(src).
        var timer = 0 //Timer variable that will help us determine when we're ready to attack.  Could shorten it to just "t".
        if(!Attacking && Target && !Target.NPC && (Target in oview(1,src))) //Move that if statement up here so that you can't attack while you're already attacking, but the attack loop goes on.  Assuming the NPC variable is constant, so that we don't have to check it multiple times.
            //We only want to do this once, so put this under the if statement instead of while loop.
            var damage = (Strength + rand(0,3)) - (Target.Defence + rand(0,3))
            if(damage < 0) //No need for checking if it is 0...
                damage = 0
            //No need for an else statement here.  Try to keep it DRY whenever you can: Don't repeat yourself.
            world << "[Target] was hit for [damage] damage!"
            Target.Health -= damage
            Attacking = 1
            Target.Attacking = 1 //We're both in an attack state here.  Also, I would just TRUE and FALSE for the Attacking variable, but I'm not going to change your design here.
            do //So we won't check twice in a row, I use a do...while loop.
                sleep(wait)
                timer += wait
                if(timer >= complete)
                    //Normally I would put timer -= complete here to restart the loop, but we're returning anyways in this case.
                    Attacking = 0
                    Target.Attacking = 0
                    Target.Attack(src) //Still using "recursion", eh?  That could be considered a flaw.  Though this is not as bad as the first time.
                    return //Return so that we don't hit the outside of the loop and so that we don't continue to do anything else.
            while(Target && (Target in oview(1,src)))  //This is an example of when we can repeat ourselves.  What would be better so that you can easily change the range is to have a range variable, but we only use this in two places, made it clear that we want it to be oview(1, src), and we use recursion so I won't even bother.  Note though, that this won't work if mobs have separate ranges, because of the recursion.  This is where not using recursion would come in handy.
            //Also, I think that using oviewers might be better because that only uses mobs.  So, those are some things to look into.

            //If we're out of range, we're both no longer attacking!
            Attacking = 0
            Target.Attacking = 0