screensaver.cpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#include "screensaver.h"
 
#include "stdafx.h"
 
#include "core/random_func.hpp"
#include "company_base.h"
#include "timer/timer.h"
#include "timer/timer_game_tick.h"
#include "vehicle_base.h"
#include "vehicle_func.h"
#include "vehicle_type.h"
#include "window_func.h"
#include "window_gui.h"
 
#include "safeguards.h"

static const Vehicle *PickRandomVehicle()
{
  /* First pass, add up vehicles of all buildable types for all companies. */
  uint n = 0;
  for (const Company *c : Company::Iterate()) {
    for (VehicleType v = VehicleType::Begin; v < VehicleType::CompanyEnd; ++v) {
      n += c->group_all[v].num_vehicle;
    }
  }
 
  /* If we have no vehicles, we can't pick a vehicle so exit. */
  if (n == 0) return nullptr;
 
  /* Otherwise, pick a random vehicle index between 0 and n. */
  n = InteractiveRandomRange(n);
 
  /* Loop over all the vehicles until we get to that vehicle. */
  for (const Vehicle *v : Vehicle::Iterate()) {
    /* Skip count anything companies can't build. */
    if (!IsCompanyBuildableVehicleType(v)) continue;
 
    /* Skip vehicles if they're not "front vehicles" so we don't count train cars (or similar) as targets to follow. */
    if (!v->IsPrimaryVehicle()) continue;
 
    /* Otherwise, it is a vehicle we should count, so count down until zero. */
    if (n-- == 0) return v;
  }
 
  /* In case we go over all the vehicles, return \c nullptr in that case. */
  return nullptr;
}

static void SwitchVehicle(bool exit_on_invalid = true)
{
  /* Do not do anything in the main menu. */
  if (_game_mode == GameMode::Menu) return;
 
  const Window *main_win = GetMainWindow();
 
  /* We start with a high chance of keeping with a moving vehicle. */
  static int movement_bias = 48;
 
  /* If we are targeting an invalid vehicle, stop running */
  if (exit_on_invalid && main_win->viewport->follow_vehicle == VehicleID::Invalid()) {
    ExitScreensaverMode();
    return;
  }
 
  /* If we're targeting a vehicle, we have a chance to return early and not pick a new one. */
  auto v = Vehicle::GetIfValid(main_win->viewport->follow_vehicle);
  if (v != nullptr) {
 
    /* Every time we stick on a moving vehicle, we make it less likely that
     * we stick around next cycle to prevent staying on one vehicle for forever. */
    if (v->cur_speed > 0 && !Chance16I(1, movement_bias, InteractiveRandom())) {
      movement_bias -= 1;
      return;
    }
 
    /* If we're not moving, we have a flat 25% chance to stay until the call
     * to encourage switching to a moving vehicle. */
    if (v->cur_speed == 0 && Chance16I(3, 4, InteractiveRandom())) {
      return;
    }
  }
 
  /* Reset our bias so that the next vehicle gets its full time. */
  movement_bias = 48;
 
  /* Try to get a vehicle (this fails if the vehicle picked isn't valid to follow). */
  const Vehicle *new_vehicle = PickRandomVehicle();
  /* If we didn't find vehicle to follow, try again next cycle. */
  if (new_vehicle == nullptr) return;
 
  /* Swap the main window over to following the new vehicle. */
  main_win->viewport->CancelFollow(*main_win);
  main_win->viewport->follow_vehicle = new_vehicle->index;
}
 
 
/* The screensaver is based off a timer on a fixed interval which rotates between vehicles. */

const static auto _screensaver_check_interval = TimerGameTick::TPeriod(TimerGameTick::Priority::None, 128);

static std::unique_ptr<IntervalTimer<TimerGameTick>> _switch_timer;

void ExitScreensaverMode()
{
  const Window *main_win = GetMainWindow();
 
  _switch_timer.reset();
  main_win->viewport->CancelFollow(*main_win);
}

void ToggleScreensaverMode()
{
  /* If we are in screensaver mode, exit it. */
  if (_switch_timer != nullptr) {
    ExitScreensaverMode();
    return;
  }
 
  /* If we aren't, start it with a new timer. */
  _switch_timer = std::make_unique<IntervalTimer<TimerGameTick>>(
    _screensaver_check_interval,
    [](uint) { SwitchVehicle(); }
  );
 
  /* Fire our callback once to start us following a first vehicle; otherwise we'd have to wait for the first time the timer fired.
   * We pass false here to ignore if there is no followed vehicle */
  SwitchVehicle(false);
}