//This creates a master /rank_handler object to handle
//all things rank-related.
var/rank_handler/rank_handler = new

rank_handler
    var
        list/squads
        squad/master_squad/master_squad
        const/TOTAL_SQUADS = 13

        list/character_list
        auto_scan = 1 //Automatically scan for people
                      //to add to the master squad.
        scan_time = 6000 //Scan every ten minutes.

    New()
        //When this is created, create the squads and
        //the master squad.

        squads = new(TOTAL_SQUADS)
        for(var/a = 1, a <= TOTAL_SQUADS, a ++)
            squads[a] = new/squad

        master_squad = new

        //In addition, create the character list, which
        //contains a list of player characters.
        character_list = new
        spawn() AutoScan()

    proc
        StarScan()
            auto_scan = 1
            spawn() AutoScan()

        StopScan()
            auto_scan = 0

        UpdateScanTime(t = 6000)
            scan_time = t

        AutoScan()
            while(auto_scan)

                for(var/interim_alias/m in character_list)
                    if(!auto_scan)
                        break

                    sleep(-1)

                    if(m.reiatsu > master_squad.GetLowBound())
                        Add(m, master_squad, 0)

                sleep(scan_time)

        Add(interim_alias/m, squad/s, auto_check = 1)
            if(auto_check && m.reiatsu > master_squad.GetLowBound())
                //If auto_check is true, then the
                //character will automatically be
                //checked to see if they should be
                //added to the master squad.
                master_squad.Add(m)

                return 2 //Indicate success if they
                         //have been added to the
                         //squad.

            return s && s.Add(m) //This will return
                                 //1 if they succeed
                                 //and 0 or null if
                                 //not.

squad
    var
        //Negative values indicate no member limit.
        member_limit = -1

        list/members

    proc
        Add(interim_alias/m)
            if(members && member_limit > 0 && members.len >= member_limit)
                //If there are members and there's a
                //member limit and there are more
                //members than that limit, indicate
                //that the proc failed.
                return 0

            if(!members)
                members = new

            members += m

            return 1 //Indicate success.

        Remove(interim_alias/m)
            members -= m

            if(!members.len)
                del m

            return 1 //Indicate success.

    master_squad
        /*
        In this datum, the members list will be an
        ordered list, with the highest value to the
        front.
        */

        var
            interim_alias
                captain
                lieutenant

        member_limit = 18 //18 members, after the
                          //captain and lieutenant
                          //positions.

        New()
            if(member_limit < 0)
                members = new
            else if(members > 0)
                members = new(member_limit)

        Add(interim_alias/m)
            /*
            Total overwrite of /squad.Add() for this
            situtation. Due to the fact that this is
            a ranked list, it searches to make sure
            the new addition has enough rieatsu or
            whatever and then puts them in the proper
            position, kicking the last person on the
            list.
            */

            var/interim_alias/n = members[members.len]
            if(m.reiatsu > n.reiatsu)
                for(var/a = 1, a <= members.len, a ++)
                    var/interim_alias/o = members[a]
                    if(m.reiatsu > o.reiatsu)
                        members.Insert(a, m)

                n.KickFromSquad()

                return 1 //Indicate success.

            return 0 //Indicate failure.

        Remove(interim_alias/m)
            ..(m)

            if(m == captain)
                captain = null
            if(m == lieutenant)
                lieutenant = null

        proc
            SetCaptain(interim_alias/m)
                captain = m

                m.current_squad.Remove(m)
                m.current_squad = src

            SetLieutenant(interim_alias/m)
                lieutenant = m

                m.current_squad.Remove(m)
                m.current_squad = src

            GetLowBound()
                //Gets the lowest rieatsu or whatever,
                //which should be the last character
                //in the listing. As the entire list
                //might not be filled, this isn't
                //a certainty.

                . = null
                for(var/interim_alias/m in members)
                    if(. == null)
                        . = m.reiatsu
                    else if(m.reiatsu < .)
                        . = m.reiatsu

interim_alias
    var
        mob/master

        squad/current_squad
        reiatsu = 0

    New(char_hash)
        tag = char_hash
        rank_handler.character_list += src

    proc
        GetCharHash()
            return tag

        Attach(mob/m)
            master = m

            master.SetSquad(current_squad)
            master.reiatsu = reiatsu

        Detach()
            master = null

        SetSquad(squad/squad)
            current_squad.Remove(src)
            current_squad = squad

            master.SetSquad(squad)

        KickFromSquad()
            master.KickFromSquad()

mob
    var
        reiatsu = 0
        squad/current_squad

        interim_alias/alias

    Login()
        ..()
        ConnectAlias()

    Logout()
        DisconnectAlias()

    proc
        ConnectAlias()
            alias = locate(GetCharHash())

            if(!alias)
                alias = new(GetCharHash())

            alias.Attach(src)

        DisconnectAlias()
            alias.Detach()

        GetCharHash()
            //This produces a (very likely) unique
            //identifier for a character.
            if(!(client && client.ckey) && !key)
                //If there's no indication that this mob
                //is a player character, then don't send
                //an identifier.
                return 0

            var/base = client ? client.ckey : key
            base += "/[name]"

            return md5(base)

        SetSquad(squad/new_squad)
            //This exists so you can easily alter other
            //values for the squad if you see a need for
            //them.

            current_squad = new_squad

        KickFromSquad()
            //This is what happens when they're kicked
            //from a squad. In my definition, it's just
            //an alias for SetSquad(), where the argument
            //is null. I'm sure youll want something more,
            //though.

            SetSquad(null)