mob
  var
    health
    death_icon_state

  proc
    Damage(dam = 0, mob/attacker)
      // dam only refers to *attempted* damage, not necessarily the actual
      // damage inflicted. In the default implementation, though, they are the
      // same unless it would make health negative.

      // If dam > health, then we will only do as many points of damage
      // as there are points of health left.
      dam = max(health, dam)
      health -= dam

      if(health <= 0)
        // When health is less than or equal to 0 (less than here is
        // just in case) then we call the Die() method to handle the actual
        // stuff that happens on death.
        Die(attacker)

      return dam

    Die(mob/attacker)
      icon_state = death_icon_state

    Dead()
      // Returns true when dead, and false otherwise.
      return (health <= 0)

mob/troll
  var
    damage = 10
    damage_variance = 1

  proc
    Target(mob/m)
      while(!Dead() && !m.Dead())
        // ! is logical not. For example, !true is false and !false is true.
        // Basically, this says that so long as the troll is alive and so is
        // its target, keep attacking.

        if(get_dist(src, m) <= 1)
           // If we're within one tile of the target, try and attack.
           Attack(m)

           walk(src, 0) // Terminate any movement if we're within range.

        else
           // Refer to the ref for what these arguments mean. One reason I don't
           // like the various step and walk methods is because of
           // how opaque their arguments are.
           walk_towards(src, m, 1, 5, 0)

        sleep(10) // Wait one second between each iteration.

    Attack(mob/target)
      // Does a random amount of damage between damage - damage_variance and
      // damage + damage_variance.
      return t.Damage(
        damage + rand(-damage_variance, damage_variance),
        src
      )

mob/troll/unkillable
  // This troll is, strictly-speaking, not able to be killed, but when its health reaches a certain
  // point it can no longer move and it does a pittance in terms of damage. At that point, it is
  // basically just a very angry statue.

  var
    lock_movement = 0 // When true, it can no longer move.

    max_health = 100
    lock_health = 5

  New()
    health = max_health
    return ..()

  Move()
    return !lock_movement && ..()

  Damage(dam, mob/attacker)
    if(health <= lock_health)
      // No damage is done if it's below its threshold.
      return 0

    else
      // If it's not below is threshold yet, then we have to compute some things.

      dam *= 1/(max_health - health + 1) // Less-and-less damage is done as it has lower health.

      if((health - dam) <= lock_health)
        // If this would bring it below its threshold, just set it equal to that threshold.
        health = lock_health

        // And now it can no longer move.
        lock_movement = 1

      else
        health -= dam

      // Now we update the damage it does based on its health. It will always do at least one base damage, though
      // this can mean between 0 and 2 damage due to variance.
      damage = (health - damage_threshold + 1)**2

    return dam // And output how much damage was done.

mob/troll/respawner
  // This troll will, upon the first time it is killed, respawn into a bigger,
  // badder, and more-dangerous version.

  var
    buff_icon_state

    max_health = 50
    buff_scale = 4 // Gets a buff of x4 on all stats when it respawns.

    const
      BASE_STATE = 0
      BUFF_STATE = 1
      DEAD_STATE = 2

    // Its current state.
    state = BASE_STATE

  Attack(mob/target)
    var/dam = damage + rand(-damage_variance, damage_variance)

    if(state == BUFF_STATE)
      // When in its buff_state, we apply the buff_scale to damage output.
      dam *= buff_scale

    return target.Damage(dam, src)

  Damage(dam, mob/attacker)
    if(state == BUFF_STATE)
      // In its buff_state, it gets a damage reduction.
      dam /= buff_scale

    // This calls the parent proc with the given arguments. That is, it does what Damage() does in
    // mob/Damage() above, with the given arguments.
    return ..(dam, attacker)

  Die(mob/attacker)
    // Here, you could maybe exploit the attacker argument to make this variant of the troll only
    // target its attacker, and ignore anything else. This is an example of why such an argument
    // can be useful when defined ahead of time, even if you don't need it now. I'm not gonna quite
    // do that here, though.

    if(state == BASE_STATE)
      // When dying in the base state, change to the buff_state.

      state = BUFF_STATE
      icon = buff_icon_state
      health = max_health * buff_scale

   else if(state == BUFF_STATE)
     // When dying in the buff state, then it just dies as usual.

     state = DEAD_STATE
     ..()

  Dead()
    return (state == DEAD_STATE)