regenupdate

void regenupdate()
{
    loopv(clients) clients[i]->state.inbase = false;
    loopi(MAXBASES) if(sbaseinfos[i].valid)
    {
        sbaseinfo &b = sbaseinfos[i];

        // calculate the amount of players in this base
        vector<int> playersinbase[2];
        loopvj(clients) if(clients[j]->type == ST_TCPIP && clients[j]->isauthed
            && clients[j]->state.state == CS_ALIVE && team_isactive(clients[j]->team)
            && !clients[j]->state.inbase)
        {
            client *cl = clients[j];
            clientstate &cs = cl->state;
            float sqrdist = ((cs.o.x - b.x) * (cs.o.x - b.x) + (cs.o.y - b.y) * (cs.o.y - b.y));
            cs.basesdist[i] = (int)fSqrt(sqrdist); // do some little caching
            bool inbase = sqrdist <= (b.radius * b.radius);
            if(inbase)
            {
                cs.inbase = true;
                playersinbase[cl->team].add(cl->clientnum);
                if(cs.curbase != &b)
                {
                    cs.lastbaseaction = gamemillis;
                    cs.curbase = &b;
                }
            }
        }

        int dp = playersinbase[0].length() - playersinbase[1].length();
        int powerdt = max(700 - 175 * (abs(dp)-1), 200); // interval between 2 power updates
        int dominant = dp == 0 ? -1 : (dp > 0 ? 0 : 1);
        // if the dominant team changed, we reset lastaction
        if(dominant != b.dominant) b.lastaction = gamemillis;

        // capture management
        if(dp && b.power[dominant] < 100 && gamemillis - b.lastaction > powerdt) // if a team has been dominating long enough...
        {
            // update lastaction and power
            b.lastaction = gamemillis;
            b.power[dominant] += 5;
            b.power[team_opposite(dominant)] -= 5;
            loopvj(playersinbase[dominant])
            {
                clients[j]->state.basespts[i] += RGCAPTPT;
                addpt(clients[j], RGCAPTPT);
            }

            if(b.power[dominant] > 50)
            {
                if(dominant != b.curowner && b.state != BASE_CAPTURING)
                {
                    if(b.curowner != -1)
                    {
                        logline(ACLOG_INFO, "team %s lost base %d", team_basestring(b.curowner), i);
                        // reset player contribution when their team lost the base
                        loopvj(clients) if(clients[j]->type == ST_TCPIP && clients[j]->isauthed && clients[j]->team == b.curowner)
                            clients[j]->state.basespts[i] = 0;
                    }
                    logline(ACLOG_INFO, "team %s is capturing base %d", team_basestring(dominant), i);
                    sendf(-1, 1, "riiii", SV_BASECAPTURING, i, b.curowner, dominant);

                    b.curowner = -1;
                    b.state = BASE_CAPTURING;
                }
                if(b.power[dominant] >= 100) // base captured
                {
                    b.power[dominant] = 100;
                    b.state = BASE_CAPTURED;
                    b.lastscore = gamemillis;

                    if(b.curowner != dominant)
                    {
                        logline(ACLOG_INFO, "team %s captured base %d", team_basestring(dominant), i);
                        sendf(-1, 1, "riii", SV_BASECAPTURED, i, dominant);
                    }
                    b.curowner = dominant;
                }
            }

            if(b.power[team_opposite(dominant)] < 0) b.power[team_opposite(dominant)] = 0;
            sendf(-1, 1, "riiii", SV_BASESTATE, i, b.power[0], b.power[1]);
        }
        b.dominant = dominant;
        b.players[0] = playersinbase[0].length();
        b.players[1] = playersinbase[1].length();

        if(b.state == BASE_CAPTURED)
        {
            // score every 15 seconds
            if(gamemillis - b.lastscore > 15000)
            {
                // in AC team scores are just sums of individual scores
                // so we have to find who should be given the flag when a base scores
                // it should be the player who contributed the most to the current base
                vector<int> clientnums;
                int maxpoints = 0;
                loopvj(clients) if(clients[j]->type == ST_TCPIP && clients[j]->isauthed
                    && clients[j]->team == b.curowner)
                {
                    int points =  clients[j]->state.basespts[i];
                    if(!clientnums.length() || points > maxpoints)
                    {
                        clientnums.shrink(0);
                        maxpoints = points;
                        clientnums.add(clients[j]->clientnum);
                    }
                    else if(points == maxpoints) clientnums.add(j);
                }
                if(clientnums.length())
                {
                    int cn = clientnums[rnd(clientnums.length())];
                    int cnumber = totalclients < 13 ? totalclients : 12;
                    clientstate &cs = clients[cn]->state;
                    cs.flagscore++;
                    addpt(clients[cn], RGSCOREPT);
                    logline(ACLOG_INFO, "team %s scored (%d)", team_basestring(b.curowner), cs.flagscore);
                    sendf(-1, 1, "riii", SV_FLAGCNT, cn, cs.flagscore);
                }
                b.lastscore = gamemillis;
            }

            // regen
            if(!b.players[team_opposite(b.curowner)])
            loopvj(playersinbase[b.curowner])
            {
                clientstate &cs = clients[j]->state;
                if(gamemillis - cs.lastbaseaction > 2000
                    && (cs.health < 100 || cs.armour < 100))
                {
                    cs.health = min(cs.health + 10, powerupstats[0].max);
                    cs.armour = min(cs.armour + 10, powerupstats[I_ARMOUR-I_HEALTH].max);
                    cs.lastbaseaction = gamemillis;
                    sendf(-1, 1, "riiii", SV_BASEFEED, j, cs.health, cs.armour);
                }
            }
        }
    }
    loopv(clients) if(!clients[i]->state.inbase) clients[i]->state.curbase = NULL;
}