void regenupdate()
{
    loopi(MAXBASES)
    {
        sbaseinfo &b = sbaseinfos[i];
        if(b.radius == 0) continue;

        // calculate the amount of players in this base
        int playersinbase[2] = { 0, 0 };
        loopvj(clients) if(clients[j]->state.state == CS_ALIVE && team_isactive(clients[j]->team))
        {
            client *cl = clients[j];
            clientstate &cs = cl->state;
            bool inbase = ((cs.o.x - b.x) * (cs.o.x - b.x) + (cs.o.y - b.y) * (cs.o.y - b.y)) <= (b.radius * b.radius);
            if(inbase)
            {
                ++playersinbase[cl->team];
            }
            //if(playersinbase[cl->team] >= playersinbase[team_opposite(cl->team)]) b.commander = j;
            if(inbase != cs.inbase) cs.lastbaseaction = gamemillis;
            cs.inbase = inbase;
            if(inbase) cs.curbase = &b;
        }

        int dp = playersinbase[0] - playersinbase[1];
        int powerdt = max(700 + 50 * (abs(dp)-1), 450); // 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;

        if(dp && b.power[dominant] < 100 && gamemillis - b.lastaction > powerdt) // if a team has been dominating for 500+ ms...
        {
            // update lastaction and power
            b.lastaction = gamemillis;
            b.power[dominant] += 5;
            b.power[team_opposite(dominant)] -= 5;

            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", teamnames[b.curowner], i);
                    logline(ACLOG_INFO, "team %s is capturing base %d", teamnames[dominant], i);
                    sendf(-1, 1, "riiii", SV_BASECAPTURING, i, b.curowner, dominant);

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

                    logline(ACLOG_INFO, "team %s captured base %d", teamnames[dominant], i);
                    sendf(-1, 1, "riii", SV_BASECAPTURED, i, 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];
        b.players[1] = playersinbase[1];

        if(b.state == BASE_CAPTURED)
        {
            // score every 15 seconds w/o any enemy in the base.
            if(gamemillis - b.lastscore > 15000)
            {
                vector<int> clientnums;
                loopvj(clients) if(clients[j]->type == ST_TCPIP && clients[j]->isauthed
                    && clients[j]->team == b.curowner) clientnums.add(clients[j]->clientnum);
                if(clientnums.length())
                {
                    int cn = clientnums[rnd(clientnums.length())];
                    ++clients[cn]->state.flagscore;
                    logline(ACLOG_INFO, "team %s scored", teamnames[b.curowner]);
                    sendf(-1, 1, "riii", SV_FLAGCNT, cn, clients[cn]->state.flagscore);
                }
                b.lastscore = gamemillis;
            }

            loopvj(clients) if(clients[j]->state.state == CS_ALIVE && clients[j]->state.inbase
                && clients[j]->state.curbase == &b && clients[j]->team == b.curowner)
            {
                clientstate &cs = clients[j]->state;
                if(gamemillis - cs.lastbaseaction > 2500
                    && (cs.health < 100 || cs.armour < 100))
                {
                    cs.health = min(clients[j]->state.health + 10, 100);
                    cs.armour = min(clients[j]->state.armour + 10, 100);
                    cs.lastbaseaction = gamemillis;
                    sendf(-1, 1, "riiii", SV_BASEFEED, j, cs.health, cs.armour);
                }
            }
        }
    }
}