Autoautosave

[enu default]

AAS_TITLE = "Autoautosave";

AAS_MANUAL_CONTROL_NAME = "Manual autosave";
AAS_TOGGLE_CONTROL_NAME = "Toggle Autoautosave";

AAS_TOGGLE_ON_MESSAGE  = "Autoautosave enabled";
AAS_TOGGLE_OFF_MESSAGE = "Autoautosave disabled";

AAS_LEVEL_NOTHING     = "nothing";
AAS_LEVEL_QUIET       = "quiet";
AAS_LEVEL_VERBOSE     = "verbose";
AAS_LEVEL_EVERYTHING  = "everything";

AAS_OPTIONS_TITLE = "Autoautosave \ct⍗";

AAS_MUST_ALWAYS   = "This must be set to";
AAS_GLOBAL_TOGGLE = "Global toggle";
AAS_CONTROLS      = "Controls";

AAS_EVENT_TUNING_TITLE       = "Event Options";
AAS_REPORT_OPTIONS_TITLE     = "Log Options";

AAS_INDIVIDUAL_TOGGLES_TITLE = "Autosave Toggles";
AAS_SCREENSHOT_TOGGLES_TITLE = "Screenshot Toggles";
AAS_VOICE_OPTIONS_TITLE      = "Voice Toggles";

AAS_SCREENSHOTS_WARNING = "Warning: too many screenshot can use up disk space.";

AAS_SCREENSHOTS_SCRIPT_NOTE = "This must be set to \"On\".";

AAS_LOG_CONSOLE = "Log to console";
AAS_LOG_SCREEN  = "Log to screen";

AAS_PRINT_COLOR = "Log color";

AAS_LOG_QUIET_NOTE_1   = "Quiet:";
AAS_LOG_QUIET_NOTE_2   = "enemies, time, teleport, items.";
AAS_LOG_VERBOSE_NOTE_1 = "Verbose:";
AAS_LOG_VERBOSE_NOTE_2 = "enemies, time, teleport, items, % kills, health, armor.";

AAS_MIN_BOSS_HEALTH   = "Enemy is a boss when health is at least";
AAS_GROUP_NUMBER      = "Group is at least N enemies";
AAS_BOSS_GROUP_NUMBER = "Boss group is at least N enemies";
AAS_HEALTH_LIMIT      = "Don't save when health is less than";
AAS_BIG_HEAL_SIZE     = "Major healing amount";

AAS_LOW_HEALTH_THRESHOLD  = "Low health threshold";
AAS_HIGH_HEALTH_THRESHOLD = "High health threshold";
AAS_LOW_ARMOR_THRESHOLD   = "Low armor threshold";
AAS_HIGH_ARMOR_THRESHOLD  = "High armor threshold";

AAS_MIN_SAVE_WAIT = "Don't save until seconds passed";
AAS_PERIOD        = "Autosave every N seconds";

AAS_SAVE_ON_DROPPED      = "Save on dropped items";
AAS_SAVE_ON_DROPPED_NOTE = "Also picking up Hideous Destructor keys.";

AAS_VOICE_VOLUME  = "Voice volume";

AAS_ENABLE_ALL  = "Enable all";
AAS_DISABLE_ALL = "Disable all";

AAS_EVENT_all_kill = "All enemies down";
AAS_EVENT_boss_kill = "Boss down";
AAS_EVENT_group_kill = "No active enemies";
AAS_EVENT_group_alert = "New active enemies";
AAS_EVENT_boss_alert = "Boss alerted";
AAS_EVENT_all_items_found = "All items found";
AAS_EVENT_time_period = "Time passed";
AAS_EVENT_teleport = "Moved to another place";
AAS_EVENT_manual = "Manual save";
AAS_EVENT_important = "Something important!";
AAS_EVENT_level_start = "Level started";
AAS_EVENT_one_percent = "Last health percent!";
AAS_EVENT_enemies_10 = "Enemies 10% down";
AAS_EVENT_enemies_20 = "Enemies 20% down";
AAS_EVENT_enemies_30 = "Enemies 30% down";
AAS_EVENT_enemies_40 = "Enemies 40% down";
AAS_EVENT_enemies_50 = "Enemies 50% down";
AAS_EVENT_enemies_60 = "Enemies 60% down";
AAS_EVENT_enemies_70 = "Enemies 70% down";
AAS_EVENT_enemies_80 = "Enemies 80% down";
AAS_EVENT_enemies_90 = "Enemies 90% down";
AAS_EVENT_health_drop = "Health low";
AAS_EVENT_health_rise = "Health high";
AAS_EVENT_armor_drop = "Armor low";
AAS_EVENT_armor_rise = "Armor high";
AAS_EVENT_secret_found = "Secret found";
AAS_EVENT_powerup = "Powerup found";
AAS_EVENT_weapon = "Weapon found";
AAS_EVENT_key = "Key found";
AAS_EVENT_backpack = "Backpack found";
AAS_EVENT_new_armor = "New armor";
AAS_EVENT_big_heal = "Major healing";
AAS_EVENT_armor = "Armor found";

// SPDX-FileCopyrightText: © 2022 generic name guy

[pt]

AAS_MANUAL_CONTROL_NAME = "Autosave manual";
AAS_TOGGLE_CONTROL_NAME = "Ligar Autoautosave";

AAS_TOGGLE_ON_MESSAGE  = "Autoautosave ligado";
AAS_TOGGLE_OFF_MESSAGE = "Autoautosave desligado";

AAS_LEVEL_NOTHING     = "nada";
AAS_LEVEL_QUIET       = "quieto";
AAS_LEVEL_VERBOSE     = "verboso";
AAS_LEVEL_EVERYTHING  = "tudo";

AAS_MUST_ALWAYS   = "Isto deve estar definido como";
AAS_GLOBAL_TOGGLE = "Ligar Mod";
AAS_CONTROLS      = "Controles";

AAS_EVENT_TUNING_TITLE       = "Opções de Evento";
AAS_REPORT_OPTIONS_TITLE     = "Opções de registramento";

AAS_INDIVIDUAL_TOGGLES_TITLE = "Opções de Autosave";
AAS_SCREENSHOT_TOGGLES_TITLE = "Opções de Captura de Tela";
AAS_VOICE_OPTIONS_TITLE      = "Opções de Voz";

AAS_SCREENSHOTS_WARNING = "Aviso: Muitas capturas de tela podem usar espaço no disco.";

AAS_SCREENSHOTS_SCRIPT_NOTE = "Isto deve estar definido como \"Sim\".";

AAS_LOG_CONSOLE = "Registrar no Console";
AAS_LOG_SCREEN  = "Registrar na Tela";

AAS_PRINT_COLOR = "Cor do registro";

AAS_LOG_QUIET_NOTE_1   = "Quieto:";
AAS_LOG_QUIET_NOTE_2   = "Inimigos, tempo, teleporte, ítens.";
AAS_LOG_VERBOSE_NOTE_1 = "Verboso:";
AAS_LOG_VERBOSE_NOTE_2 = "Inimigos, tempo, teleporte, ítens, % de vítmas, vida, armadura.";

AAS_MIN_BOSS_HEALTH   = "Inimigo é um chefão quando a vida for";
AAS_GROUP_NUMBER      = "Grupo é pelo menos N inimigos";
AAS_BOSS_GROUP_NUMBER = "Grupo de chefão é pelo menos N inimigos";
AAS_HEALTH_LIMIT      = "Não salve quando a vida for menos de";
AAS_BIG_HEAL_SIZE     = "Tanto de cura grande";

AAS_LOW_HEALTH_THRESHOLD  = "Cota de vida baoxa";
AAS_HIGH_HEALTH_THRESHOLD = "Cota de vida alta";
AAS_LOW_ARMOR_THRESHOLD   = "Cota de armadura baixa";
AAS_HIGH_ARMOR_THRESHOLD  = "Cota de armadura alta";

AAS_MIN_SAVE_WAIT = "Não salve até segundos passados";
AAS_PERIOD        = "Autosalvar todos N segundos";

AAS_SAVE_ON_DROPPED      = "Salvar nos ítens derrubados";
AAS_SAVE_ON_DROPPED_NOTE = "Também pegando chaves do Hideous Destructor";

AAS_VOICE_VOLUME  = "Volume de voz";

AAS_ENABLE_ALL  = "Habilitar todos";
AAS_DISABLE_ALL = "Desabilitar todos";

AAS_EVENT_all_kill     = "Todos os inimigos foram eliminados";
AAS_EVENT_boss_kill    = "O chefão foi eliminado";
AAS_EVENT_group_kill   = "Sem mais inimigos ativos (abate em grupo)";
AAS_EVENT_group_alert  = "Novos inimigos ativos (alerta de grupo)";
AAS_EVENT_boss_alert   = "O chefão foi alertado";
AAS_EVENT_all_items_found = "Todos os ítens foram descobertos";
AAS_EVENT_time_period  = "Tempo movido";
AAS_EVENT_teleport     = "Você foi movido para outro lugar";
AAS_EVENT_manual       = "Save manual";
AAS_EVENT_important    = "Algo importante!";
AAS_EVENT_level_start  = "Nível começado";
AAS_EVENT_one_percent  = "Sua vida caiu para 1%";
AAS_EVENT_enemies_10   = "Inimigos 10% mortos";
AAS_EVENT_enemies_20   = "Inimigos 20% mortos";
AAS_EVENT_enemies_30   = "Inimigos 30% mortos";
AAS_EVENT_enemies_40   = "Inimigos 40% mortos";
AAS_EVENT_enemies_50   = "Inimigos 50% mortos";
AAS_EVENT_enemies_60   = "Inimigos 60% mortos";
AAS_EVENT_enemies_70   = "Inimigos 70% mortos";
AAS_EVENT_enemies_80   = "Inimigos 80% mortos";
AAS_EVENT_enemies_90   = "Inimigos 90% mortos";
AAS_EVENT_health_drop  = "Sua vida caiu baixo";
AAS_EVENT_health_rise  = "Sua vida subiu alto";
AAS_EVENT_armor_drop   = "Sua armadura caiu baixo";
AAS_EVENT_armor_rise   = "Sua armadura subiu alto";
AAS_EVENT_secret_found = "Um segredo foi encontrado";
AAS_EVENT_powerup      = "Um poder foi encontrado";
AAS_EVENT_weapon       = "Uma arma foi encontrada";
AAS_EVENT_key          = "Uma chave foi encontrada";
AAS_EVENT_backpack     = "Uma mochila foi encontrada";
AAS_EVENT_new_armor    = "Novo tipo de armadura";
AAS_EVENT_big_heal     = "Grande cura";
AAS_EVENT_armor        = "Armadura foi encontrada";

class aas_event
{
  enum _
  {
    all_kill         =   0,
    boss_kill        =   1,
    group_kill       =   2,
    group_alert      =   3,
    boss_alert       =   4,
    all_items_found  =   5,
    time_period      =   7,
    teleport         =   8,
    manual           =   9,
    important        =  11,
    level_start      =  12,
    one_percent      =  13,
    enemies_10       =  14,
    enemies_20       =  15,
    enemies_30       =  16,
    enemies_40       =  17,
    enemies_50       =  18,
    enemies_60       =  19,
    enemies_70       =  20,
    enemies_80       =  21,
    enemies_90       =  22,
    health_drop      = 100,
    health_rise      = 101,
    armor_drop       = 102,
    armor_rise       = 103,
    secret_found     = 104,
    powerup          = 200,
    weapon           = 201,
    key              = 202,
    backpack         = 203,
    new_armor        = 204,
    big_heal         = 205,
    armor            = 206,
  }

  static string message(int type)
  {
    switch (type)
    {
      case all_kill        : return StringTable.localize("$aas_event_all_kill");
      case boss_kill       : return StringTable.localize("$aas_event_boss_kill");
      case group_kill      : return StringTable.localize("$aas_event_group_kill");
      case group_alert     : return StringTable.localize("$aas_event_group_alert");
      case boss_alert      : return StringTable.localize("$aas_event_boss_alert");
      case all_items_found : return StringTable.localize("$aas_event_all_items_found");
      case time_period     : return StringTable.localize("$aas_event_time_period");
      case teleport        : return StringTable.localize("$aas_event_teleport");
      case manual          : return StringTable.localize("$aas_event_manual");
      case important       : return StringTable.localize("$aas_event_important");
      case level_start     : return StringTable.localize("$aas_event_level_start");
      case one_percent     : return StringTable.localize("$aas_event_one_percent");
      case enemies_10      : return StringTable.localize("$aas_event_enemies_10");
      case enemies_20      : return StringTable.localize("$aas_event_enemies_20");
      case enemies_30      : return StringTable.localize("$aas_event_enemies_30");
      case enemies_40      : return StringTable.localize("$aas_event_enemies_40");
      case enemies_50      : return StringTable.localize("$aas_event_enemies_50");
      case enemies_60      : return StringTable.localize("$aas_event_enemies_60");
      case enemies_70      : return StringTable.localize("$aas_event_enemies_70");
      case enemies_80      : return StringTable.localize("$aas_event_enemies_80");
      case enemies_90      : return StringTable.localize("$aas_event_enemies_90");
      case health_drop     : return StringTable.localize("$aas_event_health_drop");
      case health_rise     : return StringTable.localize("$aas_event_health_rise");
      case armor_drop      : return StringTable.localize("$aas_event_armor_drop");
      case armor_rise      : return StringTable.localize("$aas_event_armor_rise");
      case secret_found    : return StringTable.localize("$aas_event_secret_found");
      case powerup         : return StringTable.localize("$aas_event_powerup");
      case weapon          : return StringTable.localize("$aas_event_weapon");
      case key             : return StringTable.localize("$aas_event_key");
      case backpack        : return StringTable.localize("$aas_event_backpack");
      case new_armor       : return StringTable.localize("$aas_event_new_armor");
      case big_heal        : return StringTable.localize("$aas_event_big_heal");
      case armor           : return StringTable.localize("$aas_event_armor");
      default:
        aas_log.error(string.format("unknown event: %d", type));
        return "Unknown event type.";
    }
  }

  static string toggle_name(int type)
  {
    switch (type)
    {
      case all_kill         : return "aas_save_on_all_kill";
      case boss_kill        : return "aas_save_on_boss_kill";
      case group_kill       : return "aas_save_on_group_kill";
      case group_alert      : return "aas_save_on_group_alert";
      case boss_alert       : return "aas_save_on_boss_alert";
      case all_items_found  : return "aas_save_on_all_items_found";
      case time_period      : return "aas_save_on_time_period";
      case teleport         : return "aas_save_on_teleport";
      case manual           : return "aas_save_on_manual";
      case important        : return "aas_save_on_important";
      case level_start      : return "aas_save_on_level_start";
      case one_percent      : return "aas_save_on_one_percent";
      case enemies_10       : return "aas_save_on_enemies_10";
      case enemies_20       : return "aas_save_on_enemies_20";
      case enemies_30       : return "aas_save_on_enemies_30";
      case enemies_40       : return "aas_save_on_enemies_40";
      case enemies_50       : return "aas_save_on_enemies_50";
      case enemies_60       : return "aas_save_on_enemies_60";
      case enemies_70       : return "aas_save_on_enemies_70";
      case enemies_80       : return "aas_save_on_enemies_80";
      case enemies_90       : return "aas_save_on_enemies_90";
      case health_drop      : return "aas_save_on_health_drop";
      case health_rise      : return "aas_save_on_health_rise";
      case armor_drop       : return "aas_save_on_armor_drop";
      case armor_rise       : return "aas_save_on_armor_rise";
      case secret_found     : return "aas_save_on_secret_found";
      case powerup          : return "aas_save_on_powerup";
      case weapon           : return "aas_save_on_weapon";
      case key              : return "aas_save_on_key";
      case backpack         : return "aas_save_on_backpack";
      case new_armor        : return "aas_save_on_new_armor";
      case big_heal         : return "aas_save_on_big_heal";
      case armor            : return "aas_save_on_armor";
      default:
        aas_log.error(string.format("unknown event: %d", type));
        return "aas_unknown";
    }
  }

  static string screenshot_toggle_name(int type)
  {
    switch (type)
    {
      case all_kill        : return "aas_screenshot_on_all_kill";
      case boss_kill       : return "aas_screenshot_on_boss_kill";
      case group_kill      : return "aas_screenshot_on_group_kill";
      case group_alert     : return "aas_screenshot_on_group_alert";
      case boss_alert      : return "aas_screenshot_on_boss_alert";
      case all_items_found : return "aas_screenshot_on_all_items_found";
      case time_period     : return "aas_screenshot_on_time_period";
      case teleport        : return "aas_screenshot_on_teleport";
      case manual          : return "aas_screenshot_on_manual";
      case important       : return "aas_screenshot_on_important";
      case level_start     : return "aas_screenshot_on_level_start";
      case one_percent     : return "aas_screenshot_on_one_percent";
      case enemies_10      : return "aas_screenshot_on_enemies_10";
      case enemies_20      : return "aas_screenshot_on_enemies_20";
      case enemies_30      : return "aas_screenshot_on_enemies_30";
      case enemies_40      : return "aas_screenshot_on_enemies_40";
      case enemies_50      : return "aas_screenshot_on_enemies_50";
      case enemies_60      : return "aas_screenshot_on_enemies_60";
      case enemies_70      : return "aas_screenshot_on_enemies_70";
      case enemies_80      : return "aas_screenshot_on_enemies_80";
      case enemies_90      : return "aas_screenshot_on_enemies_90";
      case health_drop     : return "aas_screenshot_on_health_drop";
      case health_rise     : return "aas_screenshot_on_health_rise";
      case armor_drop      : return "aas_screenshot_on_armor_drop";
      case armor_rise      : return "aas_screenshot_on_armor_rise";
      case secret_found    : return "aas_screenshot_on_secret_found";
      case powerup         : return "aas_screenshot_on_powerup";
      case weapon          : return "aas_screenshot_on_weapon";
      case key             : return "aas_screenshot_on_key";
      case backpack        : return "aas_screenshot_on_backpack";
      case new_armor       : return "aas_screenshot_on_new_armor";
      case big_heal        : return "aas_screenshot_on_big_heal";
      case armor           : return "aas_screenshot_on_armor";
      default:
        aas_log.error(string.format("unknown event: %d", type));
        return "Unknown event type.";
    }
  }

  static string voice_toggle_name(int type)
  {
    switch (type)
    {
      case all_kill        : return "aas_voice_on_all_kill";
      case boss_kill       : return "aas_voice_on_boss_kill";
      case group_kill      : return "aas_voice_on_group_kill";
      case group_alert     : return "aas_voice_on_group_alert";
      case boss_alert      : return "aas_voice_on_boss_alert";
      case all_items_found : return "aas_voice_on_all_items_found";
      case time_period     : return "aas_voice_on_time_period";
      case teleport        : return "aas_voice_on_teleport";
      case manual          : return "aas_voice_on_manual";
      case important       : return "aas_voice_on_important";
      case level_start     : return "aas_voice_on_level_start";
      case one_percent     : return "aas_voice_on_one_percent";
      case enemies_10      : return "aas_voice_on_enemies_10";
      case enemies_20      : return "aas_voice_on_enemies_20";
      case enemies_30      : return "aas_voice_on_enemies_30";
      case enemies_40      : return "aas_voice_on_enemies_40";
      case enemies_50      : return "aas_voice_on_enemies_50";
      case enemies_60      : return "aas_voice_on_enemies_60";
      case enemies_70      : return "aas_voice_on_enemies_70";
      case enemies_80      : return "aas_voice_on_enemies_80";
      case enemies_90      : return "aas_voice_on_enemies_90";
      case health_drop     : return "aas_voice_on_health_drop";
      case health_rise     : return "aas_voice_on_health_rise";
      case armor_drop      : return "aas_voice_on_armor_drop";
      case armor_rise      : return "aas_voice_on_armor_rise";
      case secret_found    : return "aas_voice_on_secret_found";
      case powerup         : return "aas_voice_on_powerup";
      case weapon          : return "aas_voice_on_weapon";
      case key             : return "aas_voice_on_key";
      case backpack        : return "aas_voice_on_backpack";
      case new_armor       : return "aas_voice_on_new_armor";
      case big_heal        : return "aas_voice_on_big_heal";
      case armor           : return "aas_voice_on_armor";
      default:
        aas_log.error(string.format("unknown event: %d", type));
        return "Unknown event type.";
    }
  }
}

class aas_precache_sounds
{
  static void precache_sounds()
  {
    markSound("aas/voice0");
    markSound("aas/voice1");
    markSound("aas/voice2");
    markSound("aas/voice3");
    markSound("aas/voice4");
    markSound("aas/voice5");
    markSound("aas/voice7");
    markSound("aas/voice8");
    markSound("aas/voice9");
    markSound("aas/voice11");
    markSound("aas/voice12");
    markSound("aas/voice13");
    markSound("aas/voice14");
    markSound("aas/voice15");
    markSound("aas/voice16");
    markSound("aas/voice17");
    markSound("aas/voice18");
    markSound("aas/voice19");
    markSound("aas/voice20");
    markSound("aas/voice21");
    markSound("aas/voice22");
    markSound("aas/voice100");
    markSound("aas/voice101");
    markSound("aas/voice102");
    markSound("aas/voice103");
    markSound("aas/voice104");
    markSound("aas/voice200");
    markSound("aas/voice201");
    markSound("aas/voice202");
    markSound("aas/voice203");
    markSound("aas/voice204");
    markSound("aas/voice205");
    markSound("aas/voice206");
  }
}

// This class provides access to a user or server Cvar.
//
// Accessing Cvars through this class is faster because calling Cvar.GetCvar()
// is costly. This class caches the result of Cvar.GetCvar() and handles
// loading a savegame.
class aas_cvar
{
  static aas_cvar of(string name, PlayerInfo player = NULL)
  {
    let result = new("aas_cvar");

    result._player = player;
    result._name   = name;
    result._cvar   = NULL;

    result.load();

    return result;
  }

  string get_string() { if (_cvar == NULL) load(); return _cvar.GetString(); }
  bool   get_bool()   { if (_cvar == NULL) load(); return _cvar.GetInt();    }
  int    get_int()    { if (_cvar == NULL) load(); return _cvar.GetInt();    }
  double get_double() { if (_cvar == NULL) load(); return _cvar.GetFloat();  }

  private void load()
  {
    _cvar = Cvar.GetCvar(_name, _player);

    if (_cvar == NULL)
    {
      aas_log.error(string.Format("cvar %s not found", _name));
    }
  }

  private PlayerInfo     _player;
  private string         _name;
  private transient Cvar _cvar;
}

// This class represents the core of Autoautosave.
class aas_event_source play
{
  static aas_event_source of()
  {
    let result = new("aas_event_source");

    let last_save_time = aas_timestamp.of();

    result._clock      = aas_level_clock.of();
    result._scheduler  = aas_game_action_scheduler.of();
    result._voice      = aas_voice.of();
    result._saver = aas_saver.of(result._scheduler, result._clock, last_save_time);

    Array<aas_event_handler> handlers =
    {
      result._saver,
      aas_logger.of(aas_log_function.of(), "aas_console_log_level"),
      aas_logger.of(aas_print_function.of(aas_Fonts.findSmall()), "aas_screen_level"),
      result._voice,
      aas_screenshot_maker.of(result._scheduler)
    };
    result._handler = aas_event_handlers.of(handlers);

    result._save_timer = aas_save_timer.of(result._clock, last_save_time);

    result._old_kill_count = level.killed_monsters;
    result._old_item_count = level.found_items;

    PlayerInfo player_info  = players[consolePlayer];
    let player = PlayerPawn(player_info.mo);
    result._old_pos    = player.Pos;
    result._old_health = player.Health;
    result._old_armor  = player.CountInv("BasicArmor");
    result._old_secret_count = player_info.secretCount;

    BasicArmor armor = BasicArmor(player.FindInventory("BasicArmor"));
    if (armor) { result._old_armor_save = armor.SavePercent; }
    else       { result._old_armor_save = 0.0; }

    result._save_on_dropped = aas_cvar.of("aas_save_on_dropped");
    result._health_down     = aas_cvar.of("aas_health_threshold_down");
    result._health_up       = aas_cvar.of("aas_health_threshold_up");
    result._armor_down      = aas_cvar.of("aas_armor_threshold_down");
    result._armor_up        = aas_cvar.of("aas_armor_threshold_up");
    result._major_healing   = aas_cvar.of("aas_big_heal");

    let active_enemies_counter = aas_active_enemies_counter.of();
    let enemies_group_cvar     = aas_cvar.of("aas_group_number");
    result._active_enemies_checker = aas_active_enemies_checker.of( result._handler
                                                                  , active_enemies_counter
                                                                  , enemies_group_cvar
                                                                  , aas_event.group_alert
                                                                  , aas_event.group_kill
                                                                  );
    let active_bosses_counter = aas_active_bosses_counter.of();
    let bosses_group_cvar = aas_cvar.of("aas_boss_group_number");
    result._active_bosses_checker = aas_active_enemies_checker.of( result._handler
                                                                 , active_bosses_counter
                                                                 , bosses_group_cvar
                                                                 , aas_event.boss_alert
                                                                 , aas_event.boss_kill
                                                                 );

    return result;
  }

  void on_event(int event_type)
  {
    _handler.on_event(event_type);
  }

  void tick()
  {
    if (_save_timer.is_periodic_save() && players[consolePlayer].mo.health > 0)
    {
      on_event(aas_event.time_period);
    }

    _voice.tick();
    _active_enemies_checker.tick();
    _active_bosses_checker.tick();

    check_secrets();
    check_all_found();
    check_player_events();

    check_all_killed();
    check_kill_percents();
    _old_kill_count = level.killed_monsters;

    _scheduler.tick();
  }

  void on_thing_spawned(Actor item)
  {
    string class_name = item.getClassName();

    if (aas_su.beginsWith(class_name, "aas_"))
    {
      if (aas_su.beginsWith(class_name, "aas_pickup_"))
        aas_token(Actor.spawn("aas_token", item.pos)).init(aas_event.important,
                                                           _handler,
                                                           NULL);

      else if (aas_su.beginsWith(class_name, "aas_instant_"))
        on_event(aas_event.important);

      else if (aas_su.beginsWith(class_name, "aas_silent_instant_"))
        _saver.on_event(aas_event.important);

      return;
    }

    if (!_save_on_dropped.get_bool() && is_loading_finished()) { return; }

    static const string saving_item_classes[] =
    {
      "Key",             // keys
      "FDKeyBase",
      "QCRedCard",
      "QCYellowCard",
      "QCBlueCard",
      "QCRedSkull",
      "QCYellowSkull",
      "QCBlueSkull",
      "Weapon",          // weapons
      "Goonades",
      "SPAMMineItem",
      "PowerupGiver",    // powerups
      "TBPowerupBase",
      "MapRevealer",
      "Berserk",
      "Speeders",
      "IcarusMk8",
      "ProtectoBand",
      "BigSPAMMine",
      "GuardBoi",
      "BadassGlasses",
      "Mapisto",
      "LovebirdTag",
      "BigScorePresent",
      "BackpackItem",    // backpacks
      "Backpack2",
      "BlueprintItem",
      "NetronianBackpack",
      "Big_Coin_pickup", // other
      "BasicArmorPickup" // armor
    };
    static const int types[] =
    {
      aas_event.key,
      aas_event.key,
      aas_event.key,
      aas_event.key,
      aas_event.key,
      aas_event.key,
      aas_event.key,
      aas_event.key,
      aas_event.weapon,
      aas_event.weapon,
      aas_event.weapon,
      aas_event.powerup,
      aas_event.powerup,
      aas_event.powerup,
      aas_event.powerup,
      aas_event.powerup,
      aas_event.powerup,
      aas_event.powerup,
      aas_event.powerup,
      aas_event.powerup,
      aas_event.powerup,
      aas_event.powerup,
      aas_event.powerup,
      aas_event.powerup,
      aas_event.backpack,
      aas_event.backpack,
      aas_event.backpack,
      aas_event.backpack,
      aas_event.important,
      aas_event.armor
    };

    int n_saving_items_classes = saving_item_classes.size();
    if (n_saving_items_classes != types.size())
    {
      aas_log.error("invalid saving items");
    }

    Actor player = players[consolePlayer].mo;
    Actor owner  = (item is "Inventory") ? Inventory(item).owner : NULL;

    for (int i = 0; i < n_saving_items_classes; ++i)
    {
      string saving_class = saving_item_classes[i];

      if (!(item is saving_class || Actor.GetReplacee(class_name) is saving_class))
      {
        continue;
      }

      if (owner == NULL)
      {
        aas_token(Actor.Spawn("aas_token", item.pos)).init(types[i], _handler, item);
      }
      else if (owner == player && is_loading_finished())
      {
        // don't save on obtaining starting weapons
        string netronianBackpack = "NetronianBackpack";
        class<Actor> netronianBackpackClass = netronianBackpack;

        // don't save on BackpackItem for Netronian Chaos, save on
        // Netronian Backpack instead
        if (saving_class == "BackpackItem" && netronianBackpackClass)
        {
          return;
        }

        on_event(types[i]);
      }

      break;
    }
  }

  private void check_player_events()
  {
    PlayerInfo player = players[consolePlayer];

    int health = player.mo.health;
    if (health <= 0) return;

    {
      vector3 pos = player.mo.Pos;
      float x_diff = (pos.x - _old_pos.x);
      float y_diff = (pos.y - _old_pos.y);
      float dist = x_diff * x_diff + y_diff * y_diff;
      if (dist > 2000000.0)
      {
        aas_log.debug(string.Format("positions distance: %f", dist));
        on_event(aas_event.teleport);
      }
      _old_pos = pos;
    }

    {
      int health_down = _health_down.get_int();
      int health_up   = _health_up.get_int();
      if (health < health_down && _old_health >= health_down)
      {
        on_event(aas_event.health_drop);
      }
      else if (health > health_up && _old_health <= health_up)
      {
        on_event(aas_event.health_rise);
      }
      else if (health >= _old_health + _major_healing.get_int() && _old_health > 0)
      {
        on_event(aas_event.big_heal);
      }
      if (health == 1 && _old_health > 1)
      {
        on_event(aas_event.one_percent);
      }
      _old_health = health;
    }

    {
      int armor_count = player.mo.CountInv("BasicArmor");
      int armor_down  = _armor_down.get_int();
      int armor_up    = _armor_up.get_int();
      if (armor_count < armor_down && _old_armor >= armor_down && health > 0)
      {
        on_event(aas_event.armor_drop);
      }
      else if (armor_count > armor_up && _old_armor <= armor_up)
      {
        on_event(aas_event.armor_rise);
      }
      _old_armor = armor_count;
    }

    {
      BasicArmor armor = BasicArmor(player.mo.FindInventory("BasicArmor"));
      if (armor != NULL)
      {
        double save_percent = armor.SavePercent;
        if (save_percent != 0.0 && save_percent != _old_armor_save)
        {
          on_event(aas_event.new_armor);
        }
        _old_armor_save = save_percent;
      }
    }
  }

  private void check_secrets()
  {
    PlayerInfo player = players[consolePlayer];
    int secret_count = player.secretCount;
    if (secret_count > _old_secret_count)
    {
      on_event(aas_event.secret_found);
    }
    _old_secret_count = secret_count;
  }

  private void check_all_killed()
  {
    int kill_count = level.killed_monsters;
    if (kill_count != _old_kill_count && kill_count == level.total_monsters)
    {
      on_event(aas_event.all_kill);
    }
  }

  private void check_kill_percents()
  {
    int kill_count = level.killed_monsters;
    static const int events[] =
    {
      aas_event.enemies_10,
      aas_event.enemies_20,
      aas_event.enemies_30,
      aas_event.enemies_40,
      aas_event.enemies_50,
      aas_event.enemies_60,
      aas_event.enemies_70,
      aas_event.enemies_80,
      aas_event.enemies_90
    };

    for (int i = 0; i < 9; ++i)
    {
      int percent = (i + 1) * 10;
      int ratio   = int(ceil(level.total_monsters * percent / 100.0));
      if (_old_kill_count < ratio && kill_count >= ratio)
      {
        on_event(events[i]);
      }
    }
  }

  private void check_all_found()
  {
    int item_count = level.found_items;
    if (item_count != _old_item_count && item_count == level.total_items)
    {
      on_event(aas_event.all_items_found);
    }
    _old_item_count = item_count;
  }

  private bool is_loading_finished()
  {
    return (_clock.time() > 0);
  }

  private aas_clock         _clock;
  private aas_event_handler _handler;
  private aas_game_action_scheduler _scheduler;
  private aas_save_timer    _save_timer;
  private aas_voice         _voice;
  private aas_event_handler _saver;

  private int     _old_kill_count;
  private int     _old_item_count;
  private int     _old_secret_count;

  private vector3 _old_pos;

  private int     _old_health;
  private int     _old_armor;
  private double  _old_armor_save;

  private aas_cvar _save_on_dropped;
  private aas_cvar _health_down;
  private aas_cvar _health_up;
  private aas_cvar _armor_down;
  private aas_cvar _armor_up;
  private aas_cvar _major_healing;

  private aas_active_enemies_checker _active_enemies_checker;
  private aas_active_enemies_checker _active_bosses_checker;
}

// Makeshift functor object.
class aas_function abstract
{
  abstract void f1(string s);
}

class aas_game_action_scheduler : aas_game_actions
{
  static aas_game_action_scheduler of()
  {
    return new("aas_game_action_scheduler");
  }

  override void save()
  {
    _is_save_scheduled = true;
  }

  override void take_screenshot()
  {
    _is_screenshot_scheduled = true;
  }

  play void tick()
  {
    if (gameAction != ga_nothing)
    {
      return;
    }

    if (_is_screenshot_scheduled)
    {
      LevelLocals.MakeScreenShot();
      _is_screenshot_scheduled = false;
      return;
    }

    if (_is_save_scheduled)
    {
      LevelLocals.MakeAutoSave();
      _is_save_scheduled = false;
      return;
    }
  }

  private bool _is_save_scheduled;
  private bool _is_screenshot_scheduled;
}

class aas_game_actions abstract
{
  abstract void save();

  abstract void take_screenshot();
}

class aas_log
{
  static void print(string s)
  {
    Console.printf("%s", StringTable.Localize(s, false));
  }

  static void error(string s)
  {
    Console.printf("ERROR: Autoautosave: %s.", s);
  }

  static void debug(string s)
  {
    if (NO_DEBUG) return;
    Console.printf("DEBUG: Autoautosave: %s.", s);
  }

  const NO_DEBUG = 1; // == true
}

// This is an entry point for Autoautosave.
class aas_main : EventHandler
{
  override void NetworkProcess(ConsoleEvent event)
  {
    Array<string> command;
    event.Name.Split(command, ":");

    // All known commands have 1 argument.
    if (command.Size() != 2) return;

    if (command[0] == "aas_manual_save")
    {
      int event_type = command[1].ToInt();
      _event_source.on_event(event_type);
    }
    else if (command[0] == "aas_log")
    {
      aas_log.print(command[1]);
    }
  }

  override void PlayerEntered(PlayerEvent event)
  {
    if (is_titlemap())
    {
      destroy();
      return;
    }

    if (event.PlayerNumber != consolePlayer) return;

    aas_precache_sounds.precache_sounds();

    _event_source = aas_event_source.of();

    _event_source.on_event(aas_event.level_start);
  }

  override void WorldThingSpawned(WorldEvent event)
  {
    if (event == NULL || event.thing == NULL) return;

    _event_source.on_thing_spawned(event.thing);
  }

  override void WorldTick()
  {
    if (_event_source)
    {
      _event_source.tick();
    }
  }

  private static bool is_titlemap()
  {
    return (level.mapName ~== "TITLEMAP");
  }

  private aas_event_source _event_source;
}

class aas_save_timer play
{
  static aas_save_timer of(aas_clock clock, aas_timestamp timestamp)
  {
    let result = new("aas_save_timer");

    result._clock          = clock;
    result._last_save_time = timestamp;

    result._autosave_period_s   = aas_cvar.of("aas_autosave_period");
    result._save_on_time_period = aas_cvar.of("aas_save_on_time_period");

    return result;
  }

  bool is_periodic_save()
  {
    int  time_from_last_save = _clock.time() - _last_save_time.get_time();
    int  autosave_period     = _autosave_period_s.get_int() * TICRATE;
    bool is_period           = (time_from_last_save % autosave_period) == (autosave_period - 1);

    return is_period
      && _save_on_time_period.get_int()
      && _clock.time() > 0;
  }

  private aas_clock     _clock;
  private aas_timestamp _last_save_time;

  private aas_cvar _autosave_period_s;
  private aas_cvar _save_on_time_period;
}

// Represents a moment in time, in game ticks.
class aas_timestamp
{
  static aas_timestamp of()
  {
    let result = new("aas_timestamp");
    result._time = 0;
    return result;
  }

  void set_time(int time)
  {
    _time = time;
  }

  int get_time()
  {
    return _time;
  }

  private int _time;
}

// Creates an aas_event when pickup up.
class aas_token : Inventory
{
  Default
  {
    +Inventory.Quiet;
    +DontGib;
  }

  aas_token init(int type, aas_event_handler handler, Actor origin)
  {
    _event_type = type;
    _handler    = handler;
    _origin     = origin;
    _connected  = origin != NULL;

    return self;
  }

  override bool TryPickup(out Actor toucher)
  {
    if (_handler != NULL) _handler.on_event(_event_type);
    GoAwayAndDie();
    return true;
  }

  override void tick()
  {
    Super.tick();

    if (!_connected)
      return;

    if (_origin == NULL)
    {
      destroy();
      return;
    }

    setOrigin(_origin.pos, true);
    a_setSize(_origin.radius, _origin.height);
  }

  private int _event_type;
  private Actor _origin;
  private bool _connected;
  private aas_event_handler _handler;
}

// Universal Autoautosave Tokens can be used by map and mod authors. When a
// player walks over such a token, it causes a generic Autoautosave event (with
// a message like "Something important!").
// In settings, saves caused by tokens fall into "Important" category.
//
// Typically, Universal Autoautosave Token is an invisible object.
//
// The advantage of saving via a Universal Autoautosave Token instead of other
// saving scripts is that a token can cause a text or voice message and a
// screenshot according to player settings. Also, Autoautosave framework ensures
// that saves aren't happening too often, if the player so desires.
//
// A mod that utilizes Universal Autoautosave Tokens doesn't depend on
// Autoautosave and can be loaded without it.
//
// Universal Autosave Tokens come it two flavors:
// 1. Pickup Tokens
// 2. Instant Tokens
// 3. Silent Instant Tokens
//
// How it works: Autoautosave watches for things spawns, and if the beginning of
// the class name of the spawned thing matches one of the signatures,
// Autoautosave acts accordingly.

// This is an example of Pickup Universal Autoautosave Token.
//
// How to use:
// 1. Define a class that starts with "aas_pickup_";
// 2. Spawn this class on a spot, and autoautosave will happen when the player
//    walks over this spot.
class aas_pickup_example : Actor
{
  // Universal Autoautosave Tokens don't have to exist after being spawned.
  States
  {
  Spawn:
    TNT1 A 0;
    stop;
  }
}

// This is an example of Instant Universal Autoautosave Token.
//
// How to use:
// 1. Define a class that starts with "aas_instant_";
// 2. Spawn this class, and autoautosave happens immediately.
class aas_instant_example : Actor
{
  // These tokens don't have to exist after being spawned.
  States
  {
  Spawn:
    TNT1 A 0;
    stop;
  }
}

// This is an example of Silent Instant Universal Autoautosave Token.
//
// How to use:
// 1. Define a class that starts with "aas_instant_";
// 2. Spawn this class, and autoautosave happens immediately, without playing
//    the voice notification, and without printing to console and to screen.
class aas_silent_instant_example : Actor
{
  // These tokens don't have to exist after being spawned.
  States
  {
  Spawn:
    TNT1 A 0;
    stop;
  }
}

// This checker watches for active enemies numbers. When active enemies number
// exceeds the number specified in aas_group_number CVar, group_alert event
// is emitted. When active number reaches zero, group_kill event is emitted, but
// only if active group of enemies was detected before.
//
// There is a problem with enemies activating. They don't wake up immediately
// when they see or hear the player, only when A_Look function happens in their
// state. This class manages this problem by keeping a short history of
// activated enemy counts, and setting a timeout before emitting the next
// group_alert event.
class aas_active_enemies_checker
{
  static aas_active_enemies_checker of(aas_event_handler   handler,
                                       aas_enemies_counter counter,
                                       aas_cvar            group_number,
                                       int alert_event,
                                       int kill_event)
  {
    let result = new("aas_active_enemies_checker");

    result._handler      = handler;
    result._counter      = counter;
    result._group_number = group_number;
    result._alert_event  = alert_event;
    result._kill_event   = kill_event;

    result._is_group            = false;
    result._old_active_count    = 0;
    result._activity_statistics = aas_ring_buffer.of();

    return result;
  }

  void tick()
  {
    if (is_player_dead()) return;

    int active_enemies_count = _counter.count();
    int group_count          = _group_number.get_int();
    int newly_active_enemies = max(0, active_enemies_count - _old_active_count);

    _old_active_count = active_enemies_count;
    _timeout = max(0, _timeout - 1);

    if (_timeout == 0)
    {
      _activity_statistics.write(newly_active_enemies);
    }

    int recently_active_enemies = _activity_statistics.get_sum();

    if (recently_active_enemies >= group_count && _timeout == 0)
    {
      _is_group = true;
      _activity_statistics.clear();
      _timeout = TIMEOUT;

      on_event(_alert_event);
    }
    else if (active_enemies_count == 0 && _is_group)
    {
      _is_group = false;
      _activity_statistics.clear();

      on_event(_kill_event);
    }
  }

  private void on_event(int event_type)
  {
    _handler.on_event(event_type);
  }

  private bool is_player_dead()
  {
    return players[consolePlayer].Health <= 0;
  }

  private aas_cvar _group_number;
  private int      _is_group;
  private int      _old_active_count;

  private aas_event_handler   _handler;
  private aas_enemies_counter _counter;

  private aas_ring_buffer _activity_statistics;

  const TIMEOUT = 20;
  private int _timeout;

  private int _alert_event;
  private int _kill_event;
}

class aas_ring_buffer
{
  static aas_ring_buffer of()
  {
    let result = new("aas_ring_buffer");

    result.clear();
    result._index = 0;

    return result;
  }

  void clear()
  {
    for (int i = 0; i < SIZE; ++i)
    {
      _ring[i] = 0;
    }
  }

  void write(int n)
  {
    _ring[_index] = n;

    _index = (_index + 1) % SIZE;
  }

  int get_sum() const
  {
    int result = 0;
    for (int i = 0; i < SIZE; ++i)
    {
      result += _ring[i];
    }
    return result;
  }

  const SIZE = 20;

  private int[SIZE] _ring;
  private int       _index;
}

wait 2; map map01
wait 4; netevent test:aas_event_test
wait 4; netevent test:aas_active_enemies_checker_test
wait 6; quit