group_cmd.cpp

Go to the documentation of this file.

/* $Id: group_cmd.cpp 14422 2008-09-30 20:51:04Z rubidium $ */

#include "stdafx.h"
#include "openttd.h"
#include "variables.h"
#include "command_func.h"
#include "saveload.h"
#include "debug.h"
#include "group.h"
#include "train.h"
#include "aircraft.h"
#include "vehicle_gui.h"
#include "strings_func.h"
#include "functions.h"
#include "window_func.h"
#include "vehicle_func.h"
#include "autoreplace_base.h"
#include "autoreplace_func.h"
#include "string_func.h"
#include "company_func.h"
#include "order_func.h"
#include "oldpool_func.h"
#include "core/alloc_func.hpp"

#include "table/strings.h"

static inline void UpdateNumEngineGroup(EngineID i, GroupID old_g, GroupID new_g)
{
  if (old_g != new_g) {
    /* Decrease the num engines of EngineID i of the old group if it's not the default one */
    if (!IsDefaultGroupID(old_g) && IsValidGroupID(old_g)) GetGroup(old_g)->num_engines[i]--;

    /* Increase the num engines of EngineID i of the new group if it's not the default one */
    if (!IsDefaultGroupID(new_g) && IsValidGroupID(new_g)) GetGroup(new_g)->num_engines[i]++;
  }
}


DEFINE_OLD_POOL_GENERIC(Group, Group)


Group::Group(Owner owner)
{
  this->owner = owner;

  if (this->IsValid()) this->num_engines = CallocT<uint16>(GetEnginePoolSize());
}

Group::~Group()
{
  free(this->name);
  this->owner = INVALID_OWNER;
  free(this->num_engines);
}

bool Group::IsValid() const
{
  return this->owner != INVALID_OWNER;
}

void InitializeGroup(void)
{
  _Group_pool.CleanPool();
  _Group_pool.AddBlockToPool();
}


CommandCost CmdCreateGroup(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
  VehicleType vt = (VehicleType)p1;
  if (!IsCompanyBuildableVehicleType(vt)) return CMD_ERROR;

  if (!Group::CanAllocateItem()) return CMD_ERROR;

  if (flags & DC_EXEC) {
    Group *g = new Group(_current_company);
    g->replace_protection = false;
    g->vehicle_type = vt;

    InvalidateWindowData(GetWindowClassForVehicleType(vt), (vt << 11) | VLW_GROUP_LIST | _current_company);
  }

  return CommandCost();
}


CommandCost CmdDeleteGroup(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
  if (!IsValidGroupID(p1)) return CMD_ERROR;

  Group *g = GetGroup(p1);
  if (g->owner != _current_company) return CMD_ERROR;

  if (flags & DC_EXEC) {
    Vehicle *v;

    /* Add all vehicles belong to the group to the default group */
    FOR_ALL_VEHICLES(v) {
      if (v->group_id == g->index && v->type == g->vehicle_type) v->group_id = DEFAULT_GROUP;
    }

    /* Update backupped orders if needed */
    if (_backup_orders_data.group == g->index) _backup_orders_data.group = DEFAULT_GROUP;

    /* If we set an autoreplace for the group we delete, remove it. */
    if (_current_company < MAX_COMPANIES) {
      Company *c;
      EngineRenew *er;

      c = GetCompany(_current_company);
      FOR_ALL_ENGINE_RENEWS(er) {
        if (er->group_id == g->index) RemoveEngineReplacementForCompany(c, er->from, g->index, flags);
      }
    }

    VehicleType vt = g->vehicle_type;

    /* Delete the Replace Vehicle Windows */
    DeleteWindowById(WC_REPLACE_VEHICLE, g->vehicle_type);
    delete g;

    InvalidateWindowData(GetWindowClassForVehicleType(vt), (vt << 11) | VLW_GROUP_LIST | _current_company);
  }

  return CommandCost();
}

static bool IsUniqueGroupName(const char *name)
{
  const Group *g;
  char buf[512];

  FOR_ALL_GROUPS(g) {
    SetDParam(0, g->index);
    GetString(buf, STR_GROUP_NAME, lastof(buf));
    if (strcmp(buf, name) == 0) return false;
  }

  return true;
}

CommandCost CmdRenameGroup(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
  if (!IsValidGroupID(p1)) return CMD_ERROR;

  Group *g = GetGroup(p1);
  if (g->owner != _current_company) return CMD_ERROR;

  bool reset = StrEmpty(_cmd_text);

  if (!reset) {
    if (strlen(_cmd_text) >= MAX_LENGTH_GROUP_NAME_BYTES) return CMD_ERROR;
    if (!IsUniqueGroupName(_cmd_text)) return_cmd_error(STR_NAME_MUST_BE_UNIQUE);
  }

  if (flags & DC_EXEC) {
    /* Delete the old name */
    free(g->name);
    /* Assign the new one */
    g->name = reset ? NULL : strdup(_cmd_text);

    InvalidateWindowData(GetWindowClassForVehicleType(g->vehicle_type), (g->vehicle_type << 11) | VLW_GROUP_LIST | _current_company);
  }

  return CommandCost();
}


CommandCost CmdAddVehicleGroup(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
  GroupID new_g = p1;

  if (!IsValidVehicleID(p2) || (!IsValidGroupID(new_g) && !IsDefaultGroupID(new_g))) return CMD_ERROR;

  Vehicle *v = GetVehicle(p2);

  if (IsValidGroupID(new_g)) {
    Group *g = GetGroup(new_g);
    if (g->owner != _current_company || g->vehicle_type != v->type) return CMD_ERROR;
  }

  if (v->owner != _current_company || !v->IsPrimaryVehicle()) return CMD_ERROR;

  if (flags & DC_EXEC) {
    DecreaseGroupNumVehicle(v->group_id);
    IncreaseGroupNumVehicle(new_g);

    switch (v->type) {
      default: NOT_REACHED();
      case VEH_TRAIN:
        SetTrainGroupID(v, new_g);
        break;
      case VEH_ROAD:
      case VEH_SHIP:
      case VEH_AIRCRAFT:
        if (IsEngineCountable(v)) UpdateNumEngineGroup(v->engine_type, v->group_id, new_g);
        v->group_id = new_g;
        break;
    }

    /* Update the Replace Vehicle Windows */
    InvalidateWindow(WC_REPLACE_VEHICLE, v->type);
    InvalidateWindowData(GetWindowClassForVehicleType(v->type), (v->type << 11) | VLW_GROUP_LIST | _current_company);
  }

  return CommandCost();
}

CommandCost CmdAddSharedVehicleGroup(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
  VehicleType type = (VehicleType)p2;
  if (!IsValidGroupID(p1) || !IsCompanyBuildableVehicleType(type)) return CMD_ERROR;

  if (flags & DC_EXEC) {
    Vehicle *v;
    VehicleType type = (VehicleType)p2;
    GroupID id_g = p1;

    /* Find the first front engine which belong to the group id_g
     * then add all shared vehicles of this front engine to the group id_g */
    FOR_ALL_VEHICLES(v) {
      if (v->type == type && v->IsPrimaryVehicle()) {
        if (v->group_id != id_g) continue;

        /* For each shared vehicles add it to the group */
        for (Vehicle *v2 = v->FirstShared(); v2 != NULL; v2 = v2->NextShared()) {
          if (v2->group_id != id_g) CmdAddVehicleGroup(tile, flags, id_g, v2->index);
        }
      }
    }

    InvalidateWindowData(GetWindowClassForVehicleType(type), (type << 11) | VLW_GROUP_LIST | _current_company);
  }

  return CommandCost();
}


CommandCost CmdRemoveAllVehiclesGroup(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
  VehicleType type = (VehicleType)p2;
  if (!IsValidGroupID(p1) || !IsCompanyBuildableVehicleType(type)) return CMD_ERROR;

  Group *g = GetGroup(p1);
  if (g->owner != _current_company) return CMD_ERROR;

  if (flags & DC_EXEC) {
    GroupID old_g = p1;
    Vehicle *v;

    /* Find each Vehicle that belongs to the group old_g and add it to the default group */
    FOR_ALL_VEHICLES(v) {
      if (v->type == type && v->IsPrimaryVehicle()) {
        if (v->group_id != old_g) continue;

        /* Add The Vehicle to the default group */
        CmdAddVehicleGroup(tile, flags, DEFAULT_GROUP, v->index);
      }
    }

    InvalidateWindowData(GetWindowClassForVehicleType(type), (type << 11) | VLW_GROUP_LIST | _current_company);
  }

  return CommandCost();
}


CommandCost CmdSetGroupReplaceProtection(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
{
  if (!IsValidGroupID(p1)) return CMD_ERROR;

  Group *g = GetGroup(p1);
  if (g->owner != _current_company) return CMD_ERROR;

  if (flags & DC_EXEC) {
    g->replace_protection = HasBit(p2, 0);

    InvalidateWindowData(GetWindowClassForVehicleType(g->vehicle_type), (g->vehicle_type << 11) | VLW_GROUP_LIST | _current_company);
  }

  return CommandCost();
}

void RemoveVehicleFromGroup(const Vehicle *v)
{
  if (!v->IsValid() || !v->IsPrimaryVehicle()) return;

  if (!IsDefaultGroupID(v->group_id)) DecreaseGroupNumVehicle(v->group_id);
}


void SetTrainGroupID(Vehicle *v, GroupID new_g)
{
  if (!IsValidGroupID(new_g) && !IsDefaultGroupID(new_g)) return;

  assert(v->IsValid() && v->type == VEH_TRAIN && IsFrontEngine(v));

  for (Vehicle *u = v; u != NULL; u = u->Next()) {
    if (IsEngineCountable(u)) UpdateNumEngineGroup(u->engine_type, u->group_id, new_g);

    u->group_id = new_g;
  }

  /* Update the Replace Vehicle Windows */
  InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);
}


void UpdateTrainGroupID(Vehicle *v)
{
  assert(v->IsValid() && v->type == VEH_TRAIN && (IsFrontEngine(v) || IsFreeWagon(v)));

  GroupID new_g = IsFrontEngine(v) ? v->group_id : (GroupID)DEFAULT_GROUP;
  for (Vehicle *u = v; u != NULL; u = u->Next()) {
    if (IsEngineCountable(u)) UpdateNumEngineGroup(u->engine_type, u->group_id, new_g);

    u->group_id = new_g;
  }

  /* Update the Replace Vehicle Windows */
  InvalidateWindow(WC_REPLACE_VEHICLE, VEH_TRAIN);
}

uint GetGroupNumEngines(CompanyID company, GroupID id_g, EngineID id_e)
{
  if (IsValidGroupID(id_g)) return GetGroup(id_g)->num_engines[id_e];

  uint num = GetCompany(company)->num_engines[id_e];
  if (!IsDefaultGroupID(id_g)) return num;

  const Group *g;
  FOR_ALL_GROUPS(g) {
    if (g->owner == company) num -= g->num_engines[id_e];
  }
  return num;
}

void RemoveAllGroupsForCompany(const CompanyID company)
{
  Group *g;

  FOR_ALL_GROUPS(g) {
    if (company == g->owner) delete g;
  }
}


static const SaveLoad _group_desc[] = {
  SLE_CONDVAR(Group, name,           SLE_NAME,    0, 83),
  SLE_CONDSTR(Group, name,           SLE_STR, 0, 84, SL_MAX_VERSION),
  SLE_VAR(Group, num_vehicle,        SLE_UINT16),
  SLE_VAR(Group, owner,              SLE_UINT8),
  SLE_VAR(Group, vehicle_type,       SLE_UINT8),
  SLE_VAR(Group, replace_protection, SLE_BOOL),
  SLE_END()
};


static void Save_GROUP(void)
{
  Group *g;

  FOR_ALL_GROUPS(g) {
    SlSetArrayIndex(g->index);
    SlObject(g, _group_desc);
  }
}


static void Load_GROUP(void)
{
  int index;

  while ((index = SlIterateArray()) != -1) {
    Group *g = new (index) Group();
    SlObject(g, _group_desc);
  }
}

extern const ChunkHandler _group_chunk_handlers[] = {
  { 'GRPS', Save_GROUP, Load_GROUP, CH_ARRAY | CH_LAST},
};