extra_firstflag.py

"""
extra_firstflag - Announce first-flag incursions and kills during the protection window.

In AAS game mode, each team's "first flag" is the outermost capturable control
point on the opponent's side (determined by sgid ordering). For a configurable
protection window after round start (default 600 s), this module:

  - Broadcasts an admin message when a player enters the opposing team's first
    flag while it is still uncapturable (FIRSTFLAG event).
  - Broadcasts an admin message when a vehicle kill occurs at the victim's own
    first flag while it is still uncapturable (FIRSTFLAGKILL event).

Both handlers are automatically unregistered once the protection window expires.

Usage (standalone):
    import extra_firstflag
    extra_firstflag.setup(protection_time=300)   # optional: override default (600 s)
    extra_firstflag.init()                        # start listening
    extra_firstflag.deinit()                      # stop listening and cancel timer

Usage (via toggler):
    # enabled=True means the module starts active (init already called by you);
    # enabled=False means it starts inactive (deinit already called / never init'd).
    g_toggler.register("firstflag", extra_firstflag.init, extra_firstflag.deinit, enabled=True)
"""

import bf2
import host
import realityadmin as radmin
import realitygamemode as rgamemode
import realitycore as rcore
import realitytimer as rtimer
import realityserver


PROTECTION_TIME = 600


g_first_flags = {1: None, 2: None}
g_enabled = False
g_fire_once_timer = None
g_protection_time = PROTECTION_TIME


def setup(protection_time=PROTECTION_TIME):
    global g_protection_time
    g_protection_time = protection_time


def init():
    global g_enabled
    g_enabled = True
    host.registerGameStatusHandler(onGameStatusChanged)
    if bf2.gameLogic.getGameStatus() == bf2.GameStatus.Playing:
        _tryStart()


def deinit():
    global g_enabled, g_fire_once_timer
    g_enabled = False
    unregisterHandlers()
    if g_fire_once_timer:
        g_fire_once_timer.destroy()
        g_fire_once_timer = None
    host.unregisterHandler(onGameStatusChanged)


def onGameStatusChanged(status):
    if status == bf2.GameStatus.Playing:
        if not g_enabled:
            return
        _tryStart()


def _tryStart():
    global g_fire_once_timer
    if rgamemode.getCurrentGameModeType() != "aas":
        return

    unregisterHandlers()
    buildFirstFlags()

    elapsed = rcore.getTimeSinceRoundStart()
    remaining = realityserver.C('STARTDELAY') + g_protection_time - elapsed
    if remaining <= 0:
        return

    host.registerHandler('EnterControlPoint', onEnterControlPoint)
    host.registerHandler('PlayerEnemyKilled', onPlayerEnemyKilled)

    g_fire_once_timer = rtimer.fireOnce(unregisterHandlers, remaining)


def unregisterHandlers(data=None):
    host.unregisterHandler(onEnterControlPoint)
    host.unregisterHandler(onPlayerEnemyKilled)


def buildFirstFlags():
    global g_first_flags
    g_first_flags = {1: None, 2: None}

    sgids = []
    for cp in rcore.getControlPoints():
        if cp.cp_getParam('unableToChangeTeam') == 1:
            continue
        sgids.append(cp.sgid)

    if not sgids:
        return

    sgids = sorted(sgids)

    # Team 1 advances from low sgid toward high sgid:
    # their first flag to capture is the lowest sgid group
    # Team 2 advances from high sgid toward low sgid:
    # their first flag to capture is the highest sgid group
    g_first_flags[1] = sgids[0]
    g_first_flags[2] = sgids[-1]


def onEnterControlPoint(player, cp):
    team = player.getTeam()

    gpm = rgamemode.getCurrentGameMode()

    if cp.cp_getParam('team') == team:
        return

    enemyTeam = 1 if team == 2 else 2

    if cp.sgid != g_first_flags[enemyTeam]:
        return

    if gpm.isCPCapturableByTeam(cp, team):
        return

    # Player entered the first flag of the opposing team's main base side
    radmin.adminPM("FIRSTFLAG: %s (%s, %s) entered first flag %s" % (
        player.getName(), rcore.getTeamName(team), player.getSquadId(), cp.text
    ), None, history=False)


def onPlayerEnemyKilled(victim, attacker, weapon, assists, obj):
    victimTeam = victim.getTeam()
    attackerTeam = attacker.getTeam()

    gpm = rgamemode.getCurrentGameMode()

    victimCP = gpm.getOccupyingCP(victim)
    if not victimCP:
        return

    if gpm.isCPCapturableByTeam(victimCP, attackerTeam):
        return

    if victimCP.sgid != g_first_flags[victimTeam]:
        return

    if attacker.getVehicle() and victim.getVehicle():
        distance = int(
            rcore.getVectorDistance(
                attacker.getVehicle().getPosition(),
                victim.getVehicle().getPosition()
            )
        )

        radmin.adminPM("FIRSTFLAGKILL: %s [%s : %s m] %s" % (
            attacker.getName(), weapon, distance, victim.getName()
        ), None, history=False)