economy.cpp

Go to the documentation of this file.

/* $Id: economy.cpp 14536 2008-10-25 22:00:51Z frosch $ */

#include "stdafx.h"
#include "openttd.h"
#include "currency.h"
#include "landscape.h"
#include "company_base.h"
#include "company_func.h"
#include "command_func.h"
#include "saveload.h"
#include "industry.h"
#include "industry_map.h"
#include "town.h"
#include "news_func.h"
#include "network/network.h"
#include "network/network_func.h"
#include "variables.h"
#include "vehicle_gui.h"
#include "ai/ai.h"
#include "train.h"
#include "roadveh.h"
#include "aircraft.h"
#include "newgrf_engine.h"
#include "newgrf_sound.h"
#include "newgrf_callbacks.h"
#include "newgrf_industries.h"
#include "newgrf_industrytiles.h"
#include "newgrf_station.h"
#include "unmovable.h"
#include "cargotype.h"
#include "group.h"
#include "strings_func.h"
#include "tile_cmd.h"
#include "functions.h"
#include "window_func.h"
#include "date_func.h"
#include "vehicle_func.h"
#include "sound_func.h"
#include "track_type.h"
#include "track_func.h"
#include "road_func.h"
#include "rail_map.h"
#include "signal_func.h"
#include "gfx_func.h"
#include "autoreplace_func.h"
#include "company_gui.h"
#include "signs_base.h"

#include "table/strings.h"
#include "table/sprites.h"

static inline int32 BigMulS(const int32 a, const int32 b, const uint8 shift)
{
  return (int32)((int64)a * (int64)b >> shift);
}

static inline uint32 BigMulSU(const uint32 a, const uint32 b, const uint8 shift)
{
  return (uint32)((uint64)a * (uint64)b >> shift);
}

/* Score info */
const ScoreInfo _score_info[] = {
  { SCORE_VEHICLES,        120, 100 },
  { SCORE_STATIONS,         80, 100 },
  { SCORE_MIN_PROFIT,    10000, 100 },
  { SCORE_MIN_INCOME,    50000,  50 },
  { SCORE_MAX_INCOME,   100000, 100 },
  { SCORE_DELIVERED,     40000, 400 },
  { SCORE_CARGO,             8,  50 },
  { SCORE_MONEY,      10000000,  50 },
  { SCORE_LOAN,         250000,  50 },
  { SCORE_TOTAL,             0,   0 }
};

int _score_part[MAX_COMPANIES][SCORE_END];
Economy _economy;
Subsidy _subsidies[MAX_COMPANIES];
Prices _price;
uint16 _price_frac[NUM_PRICES];
Money  _cargo_payment_rates[NUM_CARGO];
uint16 _cargo_payment_rates_frac[NUM_CARGO];
Money _additional_cash_required;

Money CalculateCompanyValue(const Company *c)
{
  Owner owner = c->index;
  Money value = 0;

  Station *st;
  uint num = 0;

  FOR_ALL_STATIONS(st) {
    if (st->owner == owner) num += CountBits(st->facilities);
  }

  value += num * _price.station_value * 25;

  Vehicle *v;
  FOR_ALL_VEHICLES(v) {
    if (v->owner != owner) continue;

    if (v->type == VEH_TRAIN ||
        v->type == VEH_ROAD ||
        (v->type == VEH_AIRCRAFT && IsNormalAircraft(v)) ||
        v->type == VEH_SHIP) {
      value += v->value * 3 >> 1;
    }
  }

  /* Add real money value */
  value -= c->current_loan;
  value += c->money;

  return max(value, (Money)1);
}

int UpdateCompanyRatingAndValue(Company *c, bool update)
{
  Owner owner = c->index;
  int score = 0;

  memset(_score_part[owner], 0, sizeof(_score_part[owner]));

  /* Count vehicles */
  {
    Vehicle *v;
    Money min_profit = 0;
    bool min_profit_first = true;
    uint num = 0;

    FOR_ALL_VEHICLES(v) {
      if (v->owner != owner) continue;
      if (IsCompanyBuildableVehicleType(v->type) && v->IsPrimaryVehicle()) {
        num++;
        if (v->age > 730) {
          /* Find the vehicle with the lowest amount of profit */
          if (min_profit_first || min_profit > v->profit_last_year) {
            min_profit = v->profit_last_year;
            min_profit_first = false;
          }
        }
      }
    }

    min_profit >>= 8; // remove the fract part

    _score_part[owner][SCORE_VEHICLES] = num;
    /* Don't allow negative min_profit to show */
    if (min_profit > 0)
      _score_part[owner][SCORE_MIN_PROFIT] = ClampToI32(min_profit);
  }

  /* Count stations */
  {
    uint num = 0;
    const Station* st;

    FOR_ALL_STATIONS(st) {
      if (st->owner == owner) num += CountBits(st->facilities);
    }
    _score_part[owner][SCORE_STATIONS] = num;
  }

  /* Generate statistics depending on recent income statistics */
  {
    int numec = min(c->num_valid_stat_ent, 12);
    if (numec != 0) {
      const CompanyEconomyEntry *cee = c->old_economy;
      Money min_income = cee->income + cee->expenses;
      Money max_income = cee->income + cee->expenses;

      do {
        min_income = min(min_income, cee->income + cee->expenses);
        max_income = max(max_income, cee->income + cee->expenses);
      } while (++cee,--numec);

      if (min_income > 0) {
        _score_part[owner][SCORE_MIN_INCOME] = ClampToI32(min_income);
      }

      _score_part[owner][SCORE_MAX_INCOME] = ClampToI32(max_income);
    }
  }

  /* Generate score depending on amount of transported cargo */
  {
    const CompanyEconomyEntry *cee;
    int numec;
    uint32 total_delivered;

    numec = min(c->num_valid_stat_ent, 4);
    if (numec != 0) {
      cee = c->old_economy;
      total_delivered = 0;
      do {
        total_delivered += cee->delivered_cargo;
      } while (++cee,--numec);

      _score_part[owner][SCORE_DELIVERED] = total_delivered;
    }
  }

  /* Generate score for variety of cargo */
  {
    uint num = CountBits(c->cargo_types);
    _score_part[owner][SCORE_CARGO] = num;
    if (update) c->cargo_types = 0;
  }

  /* Generate score for company's money */
  {
    if (c->money > 0) {
      _score_part[owner][SCORE_MONEY] = ClampToI32(c->money);
    }
  }

  /* Generate score for loan */
  {
    _score_part[owner][SCORE_LOAN] = ClampToI32(_score_info[SCORE_LOAN].needed - c->current_loan);
  }

  /* Now we calculate the score for each item.. */
  {
    int total_score = 0;
    int s;
    score = 0;
    for (ScoreID i = SCORE_BEGIN; i < SCORE_END; i++) {
      /* Skip the total */
      if (i == SCORE_TOTAL) continue;
      /*  Check the score */
      s = Clamp(_score_part[owner][i], 0, _score_info[i].needed) * _score_info[i].score / _score_info[i].needed;
      score += s;
      total_score += _score_info[i].score;
    }

    _score_part[owner][SCORE_TOTAL] = score;

    /*  We always want the score scaled to SCORE_MAX (1000) */
    if (total_score != SCORE_MAX) score = score * SCORE_MAX / total_score;
  }

  if (update) {
    c->old_economy[0].performance_history = score;
    UpdateCompanyHQ(c, score);
    c->old_economy[0].company_value = CalculateCompanyValue(c);
  }

  InvalidateWindow(WC_PERFORMANCE_DETAIL, 0);
  return score;
}

/*  use INVALID_OWNER as new_owner to delete the company. */
void ChangeOwnershipOfCompanyItems(Owner old_owner, Owner new_owner)
{
  Town *t;
  CompanyID old = _current_company;

  assert(old_owner != new_owner);

  {
    Company *c;
    uint i;

    /* See if the old_owner had shares in other companies */
    _current_company = old_owner;
    FOR_ALL_COMPANIES(c) {
      for (i = 0; i < 4; i++) {
        if (c->share_owners[i] == old_owner) {
          /* Sell his shares */
          CommandCost res = DoCommand(0, c->index, 0, DC_EXEC, CMD_SELL_SHARE_IN_COMPANY);
          /* Because we are in a DoCommand, we can't just execute an other one and
           *  expect the money to be removed. We need to do it ourself! */
          SubtractMoneyFromCompany(res);
        }
      }
    }

    /* Sell all the shares that people have on this company */
    c = GetCompany(old_owner);
    for (i = 0; i < 4; i++) {
      _current_company = c->share_owners[i];
      if (_current_company != INVALID_OWNER) {
        /* Sell the shares */
        CommandCost res = DoCommand(0, old_owner, 0, DC_EXEC, CMD_SELL_SHARE_IN_COMPANY);
        /* Because we are in a DoCommand, we can't just execute an other one and
         *  expect the money to be removed. We need to do it ourself! */
        SubtractMoneyFromCompany(res);
      }
    }
  }

  _current_company = old_owner;

  /* Temporarily increase the company's money, to be sure that
   * removing his/her property doesn't fail because of lack of money.
   * Not too drastically though, because it could overflow */
  if (new_owner == INVALID_OWNER) {
    GetCompany(old_owner)->money = UINT64_MAX >> 2; // jackpot ;p
  }

  if (new_owner == INVALID_OWNER) {
    Subsidy *s;

    for (s = _subsidies; s != endof(_subsidies); s++) {
      if (s->cargo_type != CT_INVALID && s->age >= 12) {
        if (GetStation(s->to)->owner == old_owner) s->cargo_type = CT_INVALID;
      }
    }
  }

  /* Take care of rating in towns */
  FOR_ALL_TOWNS(t) {
    /* If a company takes over, give the ratings to that company. */
    if (new_owner != INVALID_OWNER) {
      if (HasBit(t->have_ratings, old_owner)) {
        if (HasBit(t->have_ratings, new_owner)) {
          // use max of the two ratings.
          t->ratings[new_owner] = max(t->ratings[new_owner], t->ratings[old_owner]);
        } else {
          SetBit(t->have_ratings, new_owner);
          t->ratings[new_owner] = t->ratings[old_owner];
        }
      }
    }

    /* Reset the ratings for the old owner */
    t->ratings[old_owner] = RATING_INITIAL;
    ClrBit(t->have_ratings, old_owner);
  }

  {
    int num_train = 0;
    int num_road = 0;
    int num_ship = 0;
    int num_aircraft = 0;
    Vehicle *v;

    /*  Determine Ids for the new vehicles */
    FOR_ALL_VEHICLES(v) {
      if (v->owner == new_owner) {
        switch (v->type) {
          case VEH_TRAIN:    if (IsFrontEngine(v)) num_train++; break;
          case VEH_ROAD:     if (IsRoadVehFront(v)) num_road++; break;
          case VEH_SHIP:     num_ship++; break;
          case VEH_AIRCRAFT: if (IsNormalAircraft(v)) num_aircraft++; break;
          default: break;
        }
      }
    }

    FOR_ALL_VEHICLES(v) {
      if (v->owner == old_owner && IsInsideMM(v->type, VEH_TRAIN, VEH_AIRCRAFT + 1)) {
        if (new_owner == INVALID_OWNER) {
          DeleteWindowById(WC_VEHICLE_VIEW, v->index);
          DeleteWindowById(WC_VEHICLE_DETAILS, v->index);
          DeleteWindowById(WC_VEHICLE_ORDERS, v->index);

          if (v->IsPrimaryVehicle() || (v->type == VEH_TRAIN && IsFreeWagon(v))) {
            switch (v->type) {
              default: NOT_REACHED();

              case VEH_TRAIN: {
                Vehicle *u = v;
                do {
                  Vehicle *next = GetNextVehicle(u);
                  delete u;
                  u = next;
                } while (u != NULL);
              } break;

              case VEH_ROAD:
              case VEH_SHIP:
                delete v;
                break;

              case VEH_AIRCRAFT:
                DeleteVehicleChain(v);
                break;
            }
          }
        } else {
          v->owner = new_owner;
          v->colormap = PAL_NONE;
          v->group_id = DEFAULT_GROUP;
          if (IsEngineCountable(v)) GetCompany(new_owner)->num_engines[v->engine_type]++;
          switch (v->type) {
            case VEH_TRAIN:    if (IsFrontEngine(v)) v->unitnumber = ++num_train; break;
            case VEH_ROAD:     if (IsRoadVehFront(v)) v->unitnumber = ++num_road; break;
            case VEH_SHIP:     v->unitnumber = ++num_ship; break;
            case VEH_AIRCRAFT: if (IsNormalAircraft(v)) v->unitnumber = ++num_aircraft; break;
            default: NOT_REACHED();
          }
        }
      }
    }
  }

  /*  Change ownership of tiles */
  {
    TileIndex tile = 0;
    do {
      ChangeTileOwner(tile, old_owner, new_owner);
    } while (++tile != MapSize());

    if (new_owner != INVALID_OWNER) {
      /* Update all signals because there can be new segment that was owned by two companies
       * and signals were not propagated
       * Similiar with crossings - it is needed to bar crossings that weren't before
       * because of different owner of crossing and approaching train */
      tile = 0;

      do {
        if (IsTileType(tile, MP_RAILWAY) && IsTileOwner(tile, new_owner) && HasSignals(tile)) {
          TrackBits tracks = GetTrackBits(tile);
          do { // there may be two tracks with signals for TRACK_BIT_HORZ and TRACK_BIT_VERT
            Track track = RemoveFirstTrack(&tracks);
            if (HasSignalOnTrack(tile, track)) AddTrackToSignalBuffer(tile, track, new_owner);
          } while (tracks != TRACK_BIT_NONE);
        } else if (IsLevelCrossingTile(tile) && IsTileOwner(tile, new_owner)) {
          UpdateLevelCrossing(tile);
        }
      } while (++tile != MapSize());
    }

    /* update signals in buffer */
    UpdateSignalsInBuffer();
  }

  /* In all cases clear replace engine rules.
   * Even if it was copied, it could interfere with new owner's rules */
  RemoveAllEngineReplacementForCompany(GetCompany(old_owner));

  if (new_owner == INVALID_OWNER) {
    RemoveAllGroupsForCompany(old_owner);
  } else {
    Group *g;
    FOR_ALL_GROUPS(g) {
      if (g->owner == old_owner) g->owner = new_owner;
    }
  }

  Sign *si;
  FOR_ALL_SIGNS(si) {
    if (si->owner == old_owner) si->owner = new_owner == INVALID_OWNER ? OWNER_NONE : new_owner;
  }

  /* Change color of existing windows */
  if (new_owner != INVALID_OWNER) ChangeWindowOwner(old_owner, new_owner);

  _current_company = old;

  MarkWholeScreenDirty();
}

static void ChangeNetworkOwner(Owner current_owner, Owner new_owner)
{
#ifdef ENABLE_NETWORK
  if (!_networking) return;

  if (current_owner == _local_company) {
    _network_playas = new_owner;
    SetLocalCompany(new_owner);
  }

  if (!_network_server) return;

  NetworkServerChangeOwner(current_owner, new_owner);
#endif /* ENABLE_NETWORK */
}

static void CompanyCheckBankrupt(Company *c)
{
  /*  If the company has money again, it does not go bankrupt */
  if (c->money >= 0) {
    c->quarters_of_bankrupcy = 0;
    return;
  }

  c->quarters_of_bankrupcy++;

  CompanyNewsInformation *cni = MallocT<CompanyNewsInformation>(1);
  cni->FillData(c);

  switch (c->quarters_of_bankrupcy) {
    default:
      free(cni);
      break;

    case 2:
      SetDParam(0, STR_7056_TRANSPORT_COMPANY_IN_TROUBLE);
      SetDParam(1, STR_7057_WILL_BE_SOLD_OFF_OR_DECLARED);
      SetDParamStr(2, cni->company_name);
      AddNewsItem(STR_02B6, NS_COMPANY_TROUBLE, 0, 0, cni);
      break;
    case 3: {
      /* XXX - In multiplayer, should we ask other companies if it wants to take
              over when it is a human company? -- TrueLight */
      if (IsHumanCompany(c->index)) {
        SetDParam(0, STR_7056_TRANSPORT_COMPANY_IN_TROUBLE);
        SetDParam(1, STR_7057_WILL_BE_SOLD_OFF_OR_DECLARED);
        SetDParamStr(2, cni->company_name);
        AddNewsItem(STR_02B6, NS_COMPANY_TROUBLE, 0, 0, cni);
        break;
      }

      /* Check if the company has any value.. if not, declare it bankrupt
       *  right now */
      Money val = CalculateCompanyValue(c);
      if (val > 0) {
        c->bankrupt_value = val;
        c->bankrupt_asked = 1 << c->index; // Don't ask the owner
        c->bankrupt_timeout = 0;
        free(cni);
        break;
      }
      /* Else, falltrue to case 4... */
    }
    case 4: {
      /* Close everything the owner has open */
      DeleteCompanyWindows(c->index);

      /* Show bankrupt news */
      SetDParam(0, STR_705C_BANKRUPT);
      SetDParam(1, STR_705D_HAS_BEEN_CLOSED_DOWN_BY);
      SetDParamStr(2, cni->company_name);
      AddNewsItem(STR_02B6, NS_COMPANY_BANKRUPT, 0, 0, cni);

      if (IsHumanCompany(c->index)) {
        /* XXX - If we are in offline mode, leave the company playing. Eg. there
         * is no THE-END, otherwise mark the client as spectator to make sure
         * he/she is no long in control of this company */
        if (!_networking) {
          c->bankrupt_asked = 0xFF;
          c->bankrupt_timeout = 0x456;
          break;
        }

        ChangeNetworkOwner(c->index, COMPANY_SPECTATOR);
      }

      /* Remove the company */
      ChangeOwnershipOfCompanyItems(c->index, INVALID_OWNER);
      /* Register the company as not-active */

      if (!IsHumanCompany(c->index) && (!_networking || _network_server) && _ai.enabled)
        AI_CompanyDied(c->index);

      delete c;
    }
  }
}

static void CompaniesGenStatistics()
{
  Station *st;
  Company *c;

  FOR_ALL_STATIONS(st) {
    _current_company = st->owner;
    CommandCost cost(EXPENSES_PROPERTY, _price.station_value >> 1);
    SubtractMoneyFromCompany(cost);
  }

  if (!HasBit(1 << 0 | 1 << 3 | 1 << 6 | 1 << 9, _cur_month))
    return;

  FOR_ALL_COMPANIES(c) {
    memmove(&c->old_economy[1], &c->old_economy[0], sizeof(c->old_economy) - sizeof(c->old_economy[0]));
    c->old_economy[0] = c->cur_economy;
    memset(&c->cur_economy, 0, sizeof(c->cur_economy));

    if (c->num_valid_stat_ent != 24) c->num_valid_stat_ent++;

    UpdateCompanyRatingAndValue(c, true);
    CompanyCheckBankrupt(c);

    if (c->block_preview != 0) c->block_preview--;
  }

  InvalidateWindow(WC_INCOME_GRAPH, 0);
  InvalidateWindow(WC_OPERATING_PROFIT, 0);
  InvalidateWindow(WC_DELIVERED_CARGO, 0);
  InvalidateWindow(WC_PERFORMANCE_HISTORY, 0);
  InvalidateWindow(WC_COMPANY_VALUE, 0);
  InvalidateWindow(WC_COMPANY_LEAGUE, 0);
}

static void AddSingleInflation(Money *value, uint16 *frac, int32 amt)
{
  /* Is it safe to add inflation ? */
  if ((INT64_MAX / amt) < (*value + 1)) {
    *value = INT64_MAX / amt;
    *frac = 0;
  } else {
    int64 tmp = (int64)*value * amt + *frac;
    *frac   = GB(tmp, 0, 16);
    *value += tmp >> 16;
  }
}

static void AddInflation(bool check_year = true)
{
  /* The cargo payment inflation differs from the normal inflation, so the
   * relative amount of money you make with a transport decreases slowly over
   * the 170 years. After a few hundred years we reach a level in which the
   * games will become unplayable as the maximum income will be less than
   * the minimum running cost.
   *
   * Furthermore there are a lot of inflation related overflows all over the
   * place. Solving them is hardly possible because inflation will always
   * reach the overflow threshold some day. So we'll just perform the
   * inflation mechanism during the first 170 years (the amount of years that
   * one had in the original TTD) and stop doing the inflation after that
   * because it only causes problems that can't be solved nicely and the
   * inflation doesn't add anything after that either; it even makes playing
   * it impossible due to the diverging cost and income rates.
   */
  if (check_year && (_cur_year - _settings_game.game_creation.starting_year) >= (ORIGINAL_MAX_YEAR - ORIGINAL_BASE_YEAR)) return;

  /* Approximation for (100 + infl_amount)% ** (1 / 12) - 100%
   * scaled by 65536
   * 12 -> months per year
   * This is only a good approxiamtion for small values
   */
  int32 inf = _economy.infl_amount * 54;

  for (uint i = 0; i != NUM_PRICES; i++) {
    AddSingleInflation((Money*)&_price + i, _price_frac + i, inf);
  }

  AddSingleInflation(&_economy.max_loan_unround, &_economy.max_loan_unround_fract, inf);

  if (_economy.max_loan + 50000 <= _economy.max_loan_unround) _economy.max_loan += 50000;

  inf = _economy.infl_amount_pr * 54;
  for (CargoID i = 0; i < NUM_CARGO; i++) {
    AddSingleInflation(
      (Money*)_cargo_payment_rates + i,
      _cargo_payment_rates_frac + i,
      inf
    );
  }

  InvalidateWindowClasses(WC_BUILD_VEHICLE);
  InvalidateWindowClasses(WC_REPLACE_VEHICLE);
  InvalidateWindowClasses(WC_VEHICLE_DETAILS);
  InvalidateWindow(WC_PAYMENT_RATES, 0);
}

static void CompaniesPayInterest()
{
  const Company *c;
  int interest = _economy.interest_rate * 54;

  FOR_ALL_COMPANIES(c) {
    _current_company = c->index;

    SubtractMoneyFromCompany(CommandCost(EXPENSES_LOAN_INT, (Money)BigMulSU(c->current_loan, interest, 16)));

    SubtractMoneyFromCompany(CommandCost(EXPENSES_OTHER, _price.station_value >> 2));
  }
}

static void HandleEconomyFluctuations()
{
  if (_settings_game.difficulty.economy == 0) return;

  if (--_economy.fluct == 0) {
    _economy.fluct = -(int)GB(Random(), 0, 2);
    AddNewsItem(STR_7073_WORLD_RECESSION_FINANCIAL, NS_ECONOMY, 0, 0);
  } else if (_economy.fluct == -12) {
    _economy.fluct = GB(Random(), 0, 8) + 312;
    AddNewsItem(STR_7074_RECESSION_OVER_UPTURN_IN, NS_ECONOMY, 0, 0);
  }
}

static byte _price_category[NUM_PRICES] = {
  0, 2, 2, 2, 2, 2, 2, 2,
  2, 2, 2, 2, 2, 2, 2, 2,
  2, 2, 2, 2, 2, 2, 2, 2,
  2, 2, 2, 2, 2, 2, 2, 2,
  2, 2, 2, 2, 2, 2, 2, 2,
  2, 2, 1, 1, 1, 1, 1, 1,
  2,
};

static const Money _price_base[NUM_PRICES] = {
      100, 
      100, 
       95, 
       65, 
      275, 
      600, 
      500, 
      700, 
      450, 
      200, 
      180, 
      600, 
      200, 
      200, 
      350, 
   400000, 
     2000, 
   700000, 
    14000, 
    65000, 
       20, 
      250, 
       20, 
       40, 
      200, 
      500, 
       20, 
      -70, 
       10, 
       50, 
       80, 
       80, 
       90, 
       30, 
    10000, 
       50, 
       30, 
       50, 
       50, 
       55, 
     1600, 
       40, 
     5600, 
     5200, 
     4800, 
     9600, 
     1600, 
     5600, 
  1000000, 
};

static byte price_base_multiplier[NUM_PRICES];

void ResetPriceBaseMultipliers()
{
  uint i;

  /* 8 means no multiplier. */
  for (i = 0; i < NUM_PRICES; i++)
    price_base_multiplier[i] = 8;
}

void SetPriceBaseMultiplier(uint price, byte factor)
{
  assert(price < NUM_PRICES);
  price_base_multiplier[price] = factor;
}

static void StartupIndustryDailyChanges(bool init_counter)
{
  uint map_size = MapLogX() + MapLogY();
  /* After getting map size, it needs to be scaled appropriately and divided by 31,
   * which stands for the days in a month.
   * Using just 31 will make it so that a monthly reset (based on the real number of days of that month)
   * would not be needed.
   * Since it is based on "fractionnal parts", the leftover days will not make much of a difference
   * on the overall total number of changes performed */
  _economy.industry_daily_increment = (1 << map_size) / 31;

  if (init_counter) {
    /* A new game or a savegame from an older version will require the counter to be initialized */
    _economy.industry_daily_change_counter = 0;
  }
}

void StartupEconomy()
{
  int i;

  assert(sizeof(_price) == NUM_PRICES * sizeof(Money));

  for (i = 0; i != NUM_PRICES; i++) {
    Money price = _price_base[i];
    if (_price_category[i] != 0) {
      uint mod = _price_category[i] == 1 ? _settings_game.difficulty.vehicle_costs : _settings_game.difficulty.construction_cost;
      if (mod < 1) {
        price = price * 3 >> 2;
      } else if (mod > 1) {
        price = price * 9 >> 3;
      }
    }
    if (price_base_multiplier[i] > 8) {
      price <<= price_base_multiplier[i] - 8;
    } else {
      price >>= 8 - price_base_multiplier[i];
    }
    ((Money*)&_price)[i] = price;
    _price_frac[i] = 0;
  }

  _economy.interest_rate = _settings_game.difficulty.initial_interest;
  _economy.infl_amount = _settings_game.difficulty.initial_interest;
  _economy.infl_amount_pr = max(0, _settings_game.difficulty.initial_interest - 1);
  _economy.max_loan_unround = _economy.max_loan = _settings_game.difficulty.max_loan;
  _economy.fluct = GB(Random(), 0, 8) + 168;

  StartupIndustryDailyChanges(true); // As we are starting a new game, initialize the counter too

}

void ResetEconomy()
{
  /* Test if resetting the economy is needed. */
  bool needed = false;

  for (CargoID c = 0; c < NUM_CARGO; c++) {
    const CargoSpec *cs = GetCargo(c);
    if (!cs->IsValid()) continue;
    if (_cargo_payment_rates[c] == 0) {
      needed = true;
      break;
    }
  }

  if (!needed) return;

  /* Remember old unrounded maximum loan value. NewGRF has the ability
   * to change all the other inflation affected base costs. */
  Money old_value = _economy.max_loan_unround;

  /* Reset the economy */
  StartupEconomy();
  InitializeLandscapeVariables(false);

  /* Reapply inflation, ignoring the year */
  while (old_value > _economy.max_loan_unround) {
    AddInflation(false);
  }
}

Money GetPriceByIndex(uint8 index)
{
  if (index > NUM_PRICES) return 0;

  return ((Money*)&_price)[index];
}


Pair SetupSubsidyDecodeParam(const Subsidy* s, bool mode)
{
  TileIndex tile;
  TileIndex tile2;
  Pair tp;

  /* if mode is false, use the singular form */
  const CargoSpec *cs = GetCargo(s->cargo_type);
  SetDParam(0, mode ? cs->name : cs->name_single);

  if (s->age < 12) {
    if (cs->town_effect != TE_PASSENGERS && cs->town_effect != TE_MAIL) {
      SetDParam(1, STR_INDUSTRY);
      SetDParam(2, s->from);
      tile = GetIndustry(s->from)->xy;

      if (cs->town_effect != TE_GOODS && cs->town_effect != TE_FOOD) {
        SetDParam(4, STR_INDUSTRY);
        SetDParam(5, s->to);
        tile2 = GetIndustry(s->to)->xy;
      } else {
        SetDParam(4, STR_TOWN);
        SetDParam(5, s->to);
        tile2 = GetTown(s->to)->xy;
      }
    } else {
      SetDParam(1, STR_TOWN);
      SetDParam(2, s->from);
      tile = GetTown(s->from)->xy;

      SetDParam(4, STR_TOWN);
      SetDParam(5, s->to);
      tile2 = GetTown(s->to)->xy;
    }
  } else {
    SetDParam(1, s->from);
    tile = GetStation(s->from)->xy;

    SetDParam(2, s->to);
    tile2 = GetStation(s->to)->xy;
  }

  tp.a = tile;
  tp.b = tile2;

  return tp;
}

void DeleteSubsidyWithTown(TownID index)
{
  Subsidy *s;

  for (s = _subsidies; s != endof(_subsidies); s++) {
    if (s->cargo_type != CT_INVALID && s->age < 12) {
      const CargoSpec *cs = GetCargo(s->cargo_type);
      if (((cs->town_effect == TE_PASSENGERS || cs->town_effect == TE_MAIL) && (index == s->from || index == s->to)) ||
        ((cs->town_effect == TE_GOODS || cs->town_effect == TE_FOOD) && index == s->to)) {
        s->cargo_type = CT_INVALID;
      }
    }
  }
}

void DeleteSubsidyWithIndustry(IndustryID index)
{
  Subsidy *s;

  for (s = _subsidies; s != endof(_subsidies); s++) {
    if (s->cargo_type != CT_INVALID && s->age < 12) {
      const CargoSpec *cs = GetCargo(s->cargo_type);
      if (cs->town_effect != TE_PASSENGERS && cs->town_effect != TE_MAIL &&
        (index == s->from || (cs->town_effect != TE_GOODS && cs->town_effect != TE_FOOD && index == s->to))) {
        s->cargo_type = CT_INVALID;
      }
    }
  }
}

void DeleteSubsidyWithStation(StationID index)
{
  Subsidy *s;
  bool dirty = false;

  for (s = _subsidies; s != endof(_subsidies); s++) {
    if (s->cargo_type != CT_INVALID && s->age >= 12 &&
        (s->from == index || s->to == index)) {
      s->cargo_type = CT_INVALID;
      dirty = true;
    }
  }

  if (dirty)
    InvalidateWindow(WC_SUBSIDIES_LIST, 0);
}

struct FoundRoute {
  uint distance;
  CargoID cargo;
  void *from;
  void *to;
};

static void FindSubsidyPassengerRoute(FoundRoute *fr)
{
  Town *from,*to;

  fr->distance = UINT_MAX;

  fr->from = from = GetRandomTown();
  if (from == NULL || from->population < 400) return;

  fr->to = to = GetRandomTown();
  if (from == to || to == NULL || to->population < 400 || to->pct_pass_transported > 42)
    return;

  fr->distance = DistanceManhattan(from->xy, to->xy);
}

static void FindSubsidyCargoRoute(FoundRoute *fr)
{
  Industry *i;
  int trans, total;
  CargoID cargo;

  fr->distance = UINT_MAX;

  fr->from = i = GetRandomIndustry();
  if (i == NULL) return;

  /* Randomize cargo type */
  if (HasBit(Random(), 0) && i->produced_cargo[1] != CT_INVALID) {
    cargo = i->produced_cargo[1];
    trans = i->last_month_pct_transported[1];
    total = i->last_month_production[1];
  } else {
    cargo = i->produced_cargo[0];
    trans = i->last_month_pct_transported[0];
    total = i->last_month_production[0];
  }

  /* Quit if no production in this industry
   * or if the cargo type is passengers
   * or if the pct transported is already large enough */
  if (total == 0 || trans > 42 || cargo == CT_INVALID) return;

  const CargoSpec *cs = GetCargo(cargo);
  if (cs->town_effect == TE_PASSENGERS) return;

  fr->cargo = cargo;

  if (cs->town_effect == TE_GOODS || cs->town_effect == TE_FOOD) {
    /*  The destination is a town */
    Town *t = GetRandomTown();

    /* Only want big towns */
    if (t == NULL || t->population < 900) return;

    fr->distance = DistanceManhattan(i->xy, t->xy);
    fr->to = t;
  } else {
    /* The destination is an industry */
    Industry *i2 = GetRandomIndustry();

    /* The industry must accept the cargo */
    if (i2 == NULL || i == i2 ||
        (cargo != i2->accepts_cargo[0] &&
        cargo != i2->accepts_cargo[1] &&
        cargo != i2->accepts_cargo[2])) {
      return;
    }
    fr->distance = DistanceManhattan(i->xy, i2->xy);
    fr->to = i2;
  }
}

static bool CheckSubsidyDuplicate(Subsidy *s)
{
  const Subsidy* ss;

  for (ss = _subsidies; ss != endof(_subsidies); ss++) {
    if (s != ss &&
        ss->from == s->from &&
        ss->to == s->to &&
        ss->cargo_type == s->cargo_type) {
      s->cargo_type = CT_INVALID;
      return true;
    }
  }
  return false;
}


static void SubsidyMonthlyHandler()
{
  Subsidy *s;
  Pair pair;
  Station *st;
  uint n;
  FoundRoute fr;
  bool modified = false;

  for (s = _subsidies; s != endof(_subsidies); s++) {
    if (s->cargo_type == CT_INVALID) continue;

    if (s->age == 12-1) {
      pair = SetupSubsidyDecodeParam(s, 1);
      AddNewsItem(STR_202E_OFFER_OF_SUBSIDY_EXPIRED, NS_SUBSIDIES, pair.a, pair.b);
      s->cargo_type = CT_INVALID;
      modified = true;
    } else if (s->age == 2*12-1) {
      st = GetStation(s->to);
      if (st->owner == _local_company) {
        pair = SetupSubsidyDecodeParam(s, 1);
        AddNewsItem(STR_202F_SUBSIDY_WITHDRAWN_SERVICE, NS_SUBSIDIES, pair.a, pair.b);
      }
      s->cargo_type = CT_INVALID;
      modified = true;
    } else {
      s->age++;
    }
  }

  /* 25% chance to go on */
  if (Chance16(1,4)) {
    /*  Find a free slot*/
    s = _subsidies;
    while (s->cargo_type != CT_INVALID) {
      if (++s == endof(_subsidies))
        goto no_add;
    }

    n = 1000;
    do {
      FindSubsidyPassengerRoute(&fr);
      if (fr.distance <= 70) {
        s->cargo_type = CT_PASSENGERS;
        s->from = ((Town*)fr.from)->index;
        s->to = ((Town*)fr.to)->index;
        goto add_subsidy;
      }
      FindSubsidyCargoRoute(&fr);
      if (fr.distance <= 70) {
        s->cargo_type = fr.cargo;
        s->from = ((Industry*)fr.from)->index;
        {
          const CargoSpec *cs = GetCargo(fr.cargo);
          s->to = (cs->town_effect == TE_GOODS || cs->town_effect == TE_FOOD) ? ((Town*)fr.to)->index : ((Industry*)fr.to)->index;
        }
  add_subsidy:
        if (!CheckSubsidyDuplicate(s)) {
          s->age = 0;
          pair = SetupSubsidyDecodeParam(s, 0);
          AddNewsItem(STR_2030_SERVICE_SUBSIDY_OFFERED, NS_SUBSIDIES, pair.a, pair.b);
          modified = true;
          break;
        }
      }
    } while (n--);
  }
no_add:;
  if (modified)
    InvalidateWindow(WC_SUBSIDIES_LIST, 0);
}

static const SaveLoad _subsidies_desc[] = {
      SLE_VAR(Subsidy, cargo_type, SLE_UINT8),
      SLE_VAR(Subsidy, age,        SLE_UINT8),
  SLE_CONDVAR(Subsidy, from,       SLE_FILE_U8 | SLE_VAR_U16, 0, 4),
  SLE_CONDVAR(Subsidy, from,       SLE_UINT16,                5, SL_MAX_VERSION),
  SLE_CONDVAR(Subsidy, to,         SLE_FILE_U8 | SLE_VAR_U16, 0, 4),
  SLE_CONDVAR(Subsidy, to,         SLE_UINT16,                5, SL_MAX_VERSION),
  SLE_END()
};

static void Save_SUBS()
{
  int i;
  Subsidy *s;

  for (i = 0; i != lengthof(_subsidies); i++) {
    s = &_subsidies[i];
    if (s->cargo_type != CT_INVALID) {
      SlSetArrayIndex(i);
      SlObject(s, _subsidies_desc);
    }
  }
}

static void Load_SUBS()
{
  int index;
  while ((index = SlIterateArray()) != -1)
    SlObject(&_subsidies[index], _subsidies_desc);
}

Money GetTransportedGoodsIncome(uint num_pieces, uint dist, byte transit_days, CargoID cargo_type)
{
  const CargoSpec *cs = GetCargo(cargo_type);

  /* Use callback to calculate cargo profit, if available */
  if (HasBit(cs->callback_mask, CBM_CARGO_PROFIT_CALC)) {
    uint32 var18 = min(dist, 0xFFFF) | (min(num_pieces, 0xFF) << 16) | (transit_days << 24);
    uint16 callback = GetCargoCallback(CBID_CARGO_PROFIT_CALC, 0, var18, cs);
    if (callback != CALLBACK_FAILED) {
      int result = GB(callback, 0, 14);

      /* Simulate a 15 bit signed value */
      if (HasBit(callback, 14)) result = 0x4000 - result;

      /* "The result should be a signed multiplier that gets multiplied
       * by the amount of cargo moved and the price factor, then gets
       * divided by 8192." */
      return result * num_pieces * _cargo_payment_rates[cargo_type] / 8192;
    }
  }

  /* zero the distance (thus income) if it's the bank and very short transport. */
  if (_settings_game.game_creation.landscape == LT_TEMPERATE && cs->label == 'VALU' && dist < 10) return 0;


  static const int MIN_TIME_FACTOR = 31;
  static const int MAX_TIME_FACTOR = 255;

  const int days1 = cs->transit_days[0];
  const int days2 = cs->transit_days[1];
  const int days_over_days1 = transit_days - days1;

  /*
   * The time factor is calculated based on the time it took
   * (transit_days) compared two cargo-depending values. The
   * range is divided into three parts:
   *
   *  - constant for fast transits
   *  - linear decreasing with time with a slope of -1 for medium transports
   *  - linear decreasing with time with a slope of -2 for slow transports
   *
   */
  int time_factor;
  if (days_over_days1 <= 0) {
    time_factor = MAX_TIME_FACTOR;
  } else if (days_over_days1 <= days2) {
    time_factor = MAX_TIME_FACTOR - days_over_days1;
  } else {
    time_factor = MAX_TIME_FACTOR - 2 * days_over_days1 + days2;
  }

  if (time_factor < MIN_TIME_FACTOR) time_factor = MIN_TIME_FACTOR;

  return BigMulS(dist * time_factor * num_pieces, _cargo_payment_rates[cargo_type], 21);
}


struct FindIndustryToDeliverData {
  const Rect *rect;            
  CargoID cargo_type;          

  Industry *ind;               
  const IndustrySpec *indspec; 
  uint cargo_index;            
};

static bool FindIndustryToDeliver(TileIndex ind_tile, void *user_data)
{
  FindIndustryToDeliverData *callback_data = (FindIndustryToDeliverData *)user_data;
  const Rect *rect = callback_data->rect;
  CargoID cargo_type = callback_data->cargo_type;

  /* Only process industry tiles */
  if (!IsTileType(ind_tile, MP_INDUSTRY)) return false;

  /* Only process tiles in the station acceptance rectangle */
  int x = TileX(ind_tile);
  int y = TileY(ind_tile);
  if (x < rect->left || x > rect->right || y < rect->top || y > rect->bottom) return false;

  Industry *ind = GetIndustryByTile(ind_tile);
  const IndustrySpec *indspec = GetIndustrySpec(ind->type);

  uint cargo_index;
  for (cargo_index = 0; cargo_index < lengthof(ind->accepts_cargo); cargo_index++) {
    if (cargo_type == ind->accepts_cargo[cargo_index]) break;
  }
  /* Check if matching cargo has been found */
  if (cargo_index >= lengthof(ind->accepts_cargo)) return false;

  /* Check if industry temporarly refuses acceptance */
  if (HasBit(indspec->callback_flags,