Translations update

[openttd/fttd.git] / src / group_cmd.cpp

/* $Id$ */

/*
 * 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 <http://www.gnu.org/licenses/>.
 */

/** @file group_cmd.cpp Handling of the engine groups */

#include "stdafx.h"
#include "cmd_helper.h"
#include "command_func.h"
#include "train.h"
#include "vehiclelist.h"
#include "vehicle_func.h"
#include "autoreplace_base.h"
#include "autoreplace_func.h"
#include "string.h"
#include "company_func.h"
#include "core/pool_func.hpp"
#include "order_backup.h"

#include "table/strings.h"

GroupID _new_group_id;

template<> Group::Pool Group::PoolItem::pool ("Group");
INSTANTIATE_POOL_METHODS(Group)

GroupStatistics::GroupStatistics()
{
        this->num_engines = xcalloct<uint16>(Engine::GetPoolSize());
}

GroupStatistics::~GroupStatistics()
{
        free(this->num_engines);
}

/**
 * Clear all caches.
 */
void GroupStatistics::Clear()
{
        this->num_vehicle = 0;
        this->num_profit_vehicle = 0;
        this->profit_last_year = 0;

        /* This is also called when NewGRF change. So the number of engines might have changed. Reallocate. */
        free(this->num_engines);
        this->num_engines = xcalloct<uint16>(Engine::GetPoolSize());
}

/**
 * Returns the GroupStatistics for a specific group.
 * @param company Owner of the group.
 * @param id_g    GroupID of the group.
 * @param type    VehicleType of the vehicles in the group.
 * @return Statistics for the group.
 */
/* static */ GroupStatistics &GroupStatistics::Get(CompanyID company, GroupID id_g, VehicleType type)
{
        if (Group::IsValidID(id_g)) {
                Group *g = Group::Get(id_g);
                assert(g->owner == company);
                assert(g->vehicle_type == type);
                return g->statistics;
        }

        if (IsDefaultGroupID(id_g)) return Company::Get(company)->group_default[type];
        if (IsAllGroupID(id_g)) return Company::Get(company)->group_all[type];

        NOT_REACHED();
}

/**
 * Returns the GroupStatistic for the group of a vehicle.
 * @param v Vehicle.
 * @return GroupStatistics for the group of the vehicle.
 */
/* static */ GroupStatistics &GroupStatistics::Get(const Vehicle *v)
{
        return GroupStatistics::Get(v->owner, v->group_id, v->type);
}

/**
 * Returns the GroupStatistic for the ALL_GROUPO of a vehicle type.
 * @param v Vehicle.
 * @return GroupStatistics for the ALL_GROUP of the vehicle type.
 */
/* static */ GroupStatistics &GroupStatistics::GetAllGroup(const Vehicle *v)
{
        return GroupStatistics::Get(v->owner, ALL_GROUP, v->type);
}

/**
 * Update all caches after loading a game, changing NewGRF etc..
 */
/* static */ void GroupStatistics::UpdateAfterLoad()
{
        /* Set up the engine count for all companies */
        Company *c;
        FOR_ALL_COMPANIES(c) {
                for (VehicleType type = VEH_BEGIN; type < VEH_COMPANY_END; type++) {
                        c->group_all[type].Clear();
                        c->group_default[type].Clear();
                }
        }

        /* Recalculate */
        Group *g;
        FOR_ALL_GROUPS(g) {
                g->statistics.Clear();
        }

        const Vehicle *v;
        FOR_ALL_VEHICLES(v) {
                if (!v->IsEngineCountable()) continue;

                GroupStatistics::CountEngine(v, 1);
                if (v->IsPrimaryVehicle()) GroupStatistics::CountVehicle(v, 1);
        }

        FOR_ALL_COMPANIES(c) {
                GroupStatistics::UpdateAutoreplace(c->index);
        }
}

/**
 * Update num_vehicle when adding or removing a vehicle.
 * @param v Vehicle to count.
 * @param delta +1 to add, -1 to remove.
 */
/* static */ void GroupStatistics::CountVehicle(const Vehicle *v, int delta)
{
        assert(delta == 1 || delta == -1);

        GroupStatistics &stats_all = GroupStatistics::GetAllGroup(v);
        GroupStatistics &stats = GroupStatistics::Get(v);

        stats_all.num_vehicle += delta;
        stats.num_vehicle += delta;

        if (v->age > VEHICLE_PROFIT_MIN_AGE) {
                stats_all.num_profit_vehicle += delta;
                stats_all.profit_last_year += v->GetDisplayProfitLastYear() * delta;
                stats.num_profit_vehicle += delta;
                stats.profit_last_year += v->GetDisplayProfitLastYear() * delta;
        }
}

/**
 * Update num_engines when adding/removing an engine.
 * @param v Engine to count.
 * @param delta +1 to add, -1 to remove.
 */
/* static */ void GroupStatistics::CountEngine(const Vehicle *v, int delta)
{
        assert(delta == 1 || delta == -1);
        GroupStatistics::GetAllGroup(v).num_engines[v->engine_type] += delta;
        GroupStatistics::Get(v).num_engines[v->engine_type] += delta;
}

/**
 * Add a vehicle to the profit sum of its group.
 */
/* static */ void GroupStatistics::VehicleReachedProfitAge(const Vehicle *v)
{
        GroupStatistics &stats_all = GroupStatistics::GetAllGroup(v);
        GroupStatistics &stats = GroupStatistics::Get(v);

        stats_all.num_profit_vehicle++;
        stats_all.profit_last_year += v->GetDisplayProfitLastYear();
        stats.num_profit_vehicle++;
        stats.profit_last_year += v->GetDisplayProfitLastYear();
}

/**
 * Recompute the profits for all groups.
 */
/* static */ void GroupStatistics::UpdateProfits()
{
        /* Set up the engine count for all companies */
        Company *c;
        FOR_ALL_COMPANIES(c) {
                for (VehicleType type = VEH_BEGIN; type < VEH_COMPANY_END; type++) {
                        c->group_all[type].ClearProfits();
                        c->group_default[type].ClearProfits();
                }
        }

        /* Recalculate */
        Group *g;
        FOR_ALL_GROUPS(g) {
                g->statistics.ClearProfits();
        }

        const Vehicle *v;
        FOR_ALL_VEHICLES(v) {
                if (v->IsPrimaryVehicle() && v->age > VEHICLE_PROFIT_MIN_AGE) GroupStatistics::VehicleReachedProfitAge(v);
        }
}

/**
 * Update autoreplace_defined and autoreplace_finished of all statistics of a company.
 * @param company Company to update statistics for.
 */
/* static */ void GroupStatistics::UpdateAutoreplace(CompanyID company)
{
        /* Set up the engine count for all companies */
        Company *c = Company::Get(company);
        for (VehicleType type = VEH_BEGIN; type < VEH_COMPANY_END; type++) {
                c->group_all[type].ClearAutoreplace();
                c->group_default[type].ClearAutoreplace();
        }

        /* Recalculate */
        Group *g;
        FOR_ALL_GROUPS(g) {
                if (g->owner != company) continue;
                g->statistics.ClearAutoreplace();
        }

        for (EngineRenewList erl = c->engine_renew_list; erl != NULL; erl = erl->next) {
                const Engine *e = Engine::Get(erl->from);
                GroupStatistics &stats = GroupStatistics::Get(company, erl->group_id, e->type);
                if (!stats.autoreplace_defined) {
                        stats.autoreplace_defined = true;
                        stats.autoreplace_finished = true;
                }
                if (stats.num_engines[erl->from] > 0) stats.autoreplace_finished = false;
        }
}

/**
 * Update the num engines of a groupID. Decrease the old one and increase the new one
 * @note called in SetTrainGroupID and UpdateTrainGroupID
 * @param v     Vehicle we have to update
 * @param old_g index of the old group
 * @param new_g index of the new group
 */
static inline void UpdateNumEngineGroup(const Vehicle *v, GroupID old_g, GroupID new_g)
{
        if (old_g != new_g) {
                /* Decrease the num engines in the old group */
                GroupStatistics::Get(v->owner, old_g, v->type).num_engines[v->engine_type]--;

                /* Increase the num engines in the new group */
                GroupStatistics::Get(v->owner, new_g, v->type).num_engines[v->engine_type]++;
        }
}



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

Group::~Group()
{
        free(this->name);
}


/**
 * Create a new vehicle group.
 * @param vt vehicle type
 * @param flags type of operation
 * @return the cost of this operation or an error
 */
static CommandCost CreateNewGroup (VehicleType vt, DoCommandFlag flags)
{
        if (!Group::CanAllocateItem()) return CMD_ERROR;

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

                _new_group_id = g->index;

                InvalidateWindowData(GetWindowClassForVehicleType(vt), VehicleListIdentifier(VL_GROUP_LIST, vt, _current_company).Pack());
        }

        return CommandCost();
}

/**
 * Create a new vehicle group.
 * @param tile unused
 * @param flags type of operation
 * @param p1   vehicle type
 * @param p2   unused
 * @param text unused
 * @return the cost of this operation or an error
 */
CommandCost CmdCreateGroup(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
        VehicleType vt = Extract<VehicleType, 0, 3>(p1);
        if (!IsCompanyBuildableVehicleType(vt)) return CMD_ERROR;

        return CreateNewGroup (vt, flags);
}


/**
 * Add all vehicles in the given group to the default group and then deletes the group.
 * @param tile unused
 * @param flags type of operation
 * @param p1   index of array group
 *      - p1 bit 0-15 : GroupID
 * @param p2   unused
 * @param text unused
 * @return the cost of this operation or an error
 */
CommandCost CmdDeleteGroup(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
        Group *g = Group::GetIfValid(p1);
        if (g == NULL || g->owner != _current_company) return CMD_ERROR;

        /* Remove all vehicles from the group */
        DoCommand(0, p1, 0, flags, CMD_REMOVE_ALL_VEHICLES_GROUP);

        /* Delete sub-groups */
        Group *gp;
        FOR_ALL_GROUPS(gp) {
                if (gp->parent == g->index) {
                        DoCommand(0, gp->index, 0, flags, CMD_DELETE_GROUP);
                }
        }

        if (flags & DC_EXEC) {
                /* Update backupped orders if needed */
                OrderBackup::ClearGroup(g->index);

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

                        c = Company::Get(_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), VehicleListIdentifier(VL_GROUP_LIST, vt, _current_company).Pack());
        }

        return CommandCost();
}

static bool IsUniqueGroupNameForVehicleType(const char *name, VehicleType type)
{
        const Group *g;

        FOR_ALL_GROUPS(g) {
                if (g->name != NULL && g->vehicle_type == type && strcmp(g->name, name) == 0) return false;
        }

        return true;
}

/**
 * Alter a group
 * @param tile unused
 * @param flags type of operation
 * @param p1   index of array group
 *   - p1 bit 0-15 : GroupID
 *   - p1 bit 16: 0 - Rename group
 *                1 - Set group parent
 * @param p2   parent group index
 * @param text the new name or an empty string when resetting to the default
 * @return the cost of this operation or an error
 */
CommandCost CmdAlterGroup(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
        Group *g = Group::GetIfValid(GB(p1, 0, 16));
        if (g == NULL || g->owner != _current_company) return CMD_ERROR;

        if (!HasBit(p1, 16)) {
                /* Rename group */
                bool reset = StrEmpty(text);

                if (!reset) {
                        if (Utf8StringLength(text) >= MAX_LENGTH_GROUP_NAME_CHARS) return CMD_ERROR;
                        if (!IsUniqueGroupNameForVehicleType(text, g->vehicle_type)) return_cmd_error(STR_ERROR_NAME_MUST_BE_UNIQUE);
                }

                if (flags & DC_EXEC) {
                        /* Delete the old name */
                        free(g->name);
                        /* Assign the new one */
                        g->name = reset ? NULL : xstrdup(text);
                }
        } else {
                /* Set group parent */
                const Group *pg = Group::GetIfValid(GB(p2, 0, 16));

                if (pg != NULL) {
                        if (pg->owner != _current_company) return CMD_ERROR;
                        if (pg->vehicle_type != g->vehicle_type) return CMD_ERROR;

                        /* Ensure request parent isn't child of group.
                         * This is the only place that loops are prevented. */
                        if (GroupIsInGroup(pg->index, g->index)) return CMD_ERROR;
                }

                if (flags & DC_EXEC) {
                        g->parent = (pg == NULL) ? INVALID_GROUP : pg->index;
                }
        }

        if (flags & DC_EXEC) {
                SetWindowDirty(WC_REPLACE_VEHICLE, g->vehicle_type);
                InvalidateWindowData(GetWindowClassForVehicleType(g->vehicle_type), VehicleListIdentifier(VL_GROUP_LIST, g->vehicle_type, _current_company).Pack());
        }

        return CommandCost();
}


/**
 * Do add a vehicle to a group.
 * @param v Vehicle to add.
 * @param new_g Group to add to.
 */
static void AddVehicleToGroup(Vehicle *v, GroupID new_g)
{
        GroupStatistics::CountVehicle(v, -1);

        switch (v->type) {
                default: NOT_REACHED();
                case VEH_TRAIN:
                        SetTrainGroupID(Train::From(v), new_g);
                        break;

                case VEH_ROAD:
                case VEH_SHIP:
                case VEH_AIRCRAFT:
                        if (v->IsEngineCountable()) UpdateNumEngineGroup(v, v->group_id, new_g);
                        v->group_id = new_g;
                        break;
        }

        GroupStatistics::CountVehicle(v, 1);
}

/**
 * Add a vehicle to a group
 * @param tile unused
 * @param flags type of operation
 * @param p1   index of array group
 *   - p1 bit 0-15 : GroupID
 * @param p2   vehicle to add to a group
 *   - p2 bit 0-19 : VehicleID
 *   - p2 bit   31 : Add shared vehicles as well.
 * @param text unused
 * @return the cost of this operation or an error
 */
CommandCost CmdAddVehicleGroup(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
        Vehicle *v = Vehicle::GetIfValid(GB(p2, 0, 20));
        GroupID new_g = p1;

        if (v == NULL || (!Group::IsValidID(new_g) && !IsDefaultGroupID(new_g) && new_g != NEW_GROUP)) return CMD_ERROR;

        if (Group::IsValidID(new_g)) {
                Group *g = Group::Get(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 (new_g == NEW_GROUP) {
                /* Create new group. */
                CommandCost ret = CreateNewGroup (v->type, flags);
                if (ret.Failed()) return ret;

                new_g = _new_group_id;
        }

        if (flags & DC_EXEC) {
                AddVehicleToGroup(v, new_g);

                if (HasBit(p2, 31)) {
                        /* Add vehicles in the shared order list as well. */
                        for (Vehicle *v2 = v->FirstShared(); v2 != NULL; v2 = v2->NextShared()) {
                                if (v2->group_id != new_g) AddVehicleToGroup(v2, new_g);
                        }
                }

                GroupStatistics::UpdateAutoreplace(v->owner);

                /* Update the Replace Vehicle Windows */
                SetWindowDirty(WC_REPLACE_VEHICLE, v->type);
                InvalidateWindowData(GetWindowClassForVehicleType(v->type), VehicleListIdentifier(VL_GROUP_LIST, v->type, _current_company).Pack());
        }

        return CommandCost();
}

/**
 * Add all shared vehicles of all vehicles from a group
 * @param tile unused
 * @param flags type of operation
 * @param p1   index of group array
 *  - p1 bit 0-15 : GroupID
 * @param p2   type of vehicles
 * @param text unused
 * @return the cost of this operation or an error
 */
CommandCost CmdAddSharedVehicleGroup(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
        VehicleType type = Extract<VehicleType, 0, 3>(p2);
        GroupID id_g = p1;
        if (!Group::IsValidID(id_g) || !IsCompanyBuildableVehicleType(type)) return CMD_ERROR;

        if (flags & DC_EXEC) {
                Vehicle *v;

                /* 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) DoCommand(tile, id_g, v2->index, flags, CMD_ADD_VEHICLE_GROUP, text);
                                }
                        }
                }

                InvalidateWindowData(GetWindowClassForVehicleType(type), VehicleListIdentifier(VL_GROUP_LIST, type, _current_company).Pack());
        }

        return CommandCost();
}


/**
 * Remove all vehicles from a group
 * @param tile unused
 * @param flags type of operation
 * @param p1   index of group array
 * - p1 bit 0-15 : GroupID
 * @param p2   unused
 * @param text unused
 * @return the cost of this operation or an error
 */
CommandCost CmdRemoveAllVehiclesGroup(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
        GroupID old_g = p1;
        Group *g = Group::GetIfValid(old_g);

        if (g == NULL || g->owner != _current_company) return CMD_ERROR;

        if (flags & DC_EXEC) {
                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->IsPrimaryVehicle()) {
                                if (v->group_id != old_g) continue;

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

                InvalidateWindowData(GetWindowClassForVehicleType(g->vehicle_type), VehicleListIdentifier(VL_GROUP_LIST, g->vehicle_type, _current_company).Pack());
        }

        return CommandCost();
}

/**
 * Set replace protection for a group and its sub-groups.
 * @param g initial group.
 * @param protect 1 to set or 0 to clear protection.
 */
static void SetGroupReplaceProtection(Group *g, bool protect)
{
        g->replace_protection = protect;

        Group *pg;
        FOR_ALL_GROUPS(pg) {
                if (pg->parent == g->index) SetGroupReplaceProtection(pg, protect);
        }
}

/**
 * (Un)set global replace protection from a group
 * @param tile unused
 * @param flags type of operation
 * @param p1   index of group array
 * - p1 bit 0-15 : GroupID
 * @param p2
 * - p2 bit 0    : 1 to set or 0 to clear protection.
 * - p2 bit 1    : 1 to apply to sub-groups.
 * @param text unused
 * @return the cost of this operation or an error
 */
CommandCost CmdSetGroupReplaceProtection(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
{
        Group *g = Group::GetIfValid(p1);
        if (g == NULL || g->owner != _current_company) return CMD_ERROR;

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

                SetWindowDirty(GetWindowClassForVehicleType(g->vehicle_type), VehicleListIdentifier(VL_GROUP_LIST, g->vehicle_type, _current_company).Pack());
                InvalidateWindowData(WC_REPLACE_VEHICLE, g->vehicle_type);
        }

        return CommandCost();
}

/**
 * Decrease the num_vehicle variable before delete an front engine from a group
 * @note Called in CmdSellRailWagon and DeleteLasWagon,
 * @param v     FrontEngine of the train we want to remove.
 */
void RemoveVehicleFromGroup(const Vehicle *v)
{
        if (!v->IsPrimaryVehicle()) return;

        if (!IsDefaultGroupID(v->group_id)) GroupStatistics::CountVehicle(v, -1);
}


/**
 * Affect the groupID of a train to new_g.
 * @note called in CmdAddVehicleGroup and CmdMoveRailVehicle
 * @param v     First vehicle of the chain.
 * @param new_g index of array group
 */
void SetTrainGroupID(Train *v, GroupID new_g)
{
        if (!Group::IsValidID(new_g) && !IsDefaultGroupID(new_g)) return;

        assert(v->IsFrontEngine() || IsDefaultGroupID(new_g));

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

                u->group_id = new_g;
        }

        /* Update the Replace Vehicle Windows */
        GroupStatistics::UpdateAutoreplace(v->owner);
        SetWindowDirty(WC_REPLACE_VEHICLE, VEH_TRAIN);
}


/**
 * Recalculates the groupID of a train. Should be called each time a vehicle is added
 * to/removed from the chain,.
 * @note this needs to be called too for 'wagon chains' (in the depot, without an engine)
 * @note Called in CmdBuildRailVehicle, CmdBuildRailWagon, CmdMoveRailVehicle, CmdSellRailWagon
 * @param v First vehicle of the chain.
 */
void UpdateTrainGroupID(Train *v)
{
        assert(v->IsFrontEngine() || v->IsFreeWagon());

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

                u->group_id = new_g;
        }

        /* Update the Replace Vehicle Windows */
        GroupStatistics::UpdateAutoreplace(v->owner);
        SetWindowDirty(WC_REPLACE_VEHICLE, VEH_TRAIN);
}

/**
 * Get the number of engines with EngineID id_e in the group with GroupID
 * id_g and its sub-groups.
 * @param company The company the group belongs to
 * @param id_g The GroupID of the group used
 * @param id_e The EngineID of the engine to count
 * @return The number of engines with EngineID id_e in the group
 */
uint GetGroupNumEngines(CompanyID company, GroupID id_g, EngineID id_e)
{
        uint count = 0;
        const Engine *e = Engine::Get(id_e);
        const Group *g;
        FOR_ALL_GROUPS(g) {
                if (g->parent == id_g) count += GetGroupNumEngines(company, g->index, id_e);
        }
        return count + GroupStatistics::Get(company, id_g, e->type).num_engines[id_e];
}

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

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


/**
 * Test if GroupID needle is a descendant of (or is) GroupID haystack
 * @param needle The GroupID to search for
 * @param haystack The GroupID to search in
 * @return True iff needle is haystack or a descendant of haystack
 */
bool GroupIsInGroup (GroupID needle, GroupID haystack)
{
        if (needle == haystack) return true;

        if (!Group::IsValidID(needle)) return false;

        for (;;) {
                needle = Group::Get(needle)->parent;
                if (needle == INVALID_GROUP) return false;
                if (needle == haystack) return true;
        }
}