1

/* $Id$ */

     2

     3

/** @file ai_group.cpp Implementation of AIGroup. */

     4

     5

#include "ai_group.hpp"

     6

#include "ai_vehicle.hpp"

     7

#include "ai_engine.hpp"

     8

#include "../../openttd.h"

     9

#include "../../player_func.h"

    10

#include "../../group.h"

    11

#include "../../string_func.h"

    12

#include "../../strings_func.h"

    13

#include "../../core/alloc_func.hpp"

    14

#include "../../command_func.h"

    15

#include "../../autoreplace_func.h"

    16

#include "table/strings.h"

    17

    18

/* static */ bool AIGroup::IsValidGroup(GroupID group_id)

    19

{

    20

	return ::IsValidGroupID(group_id) && ::GetGroup(group_id)->owner == _current_player;

    21

}

    22

    23

/* static */ AIGroup::GroupID AIGroup::CreateGroup(AIVehicle::VehicleType vehicle_type)

    24

{

    25

	/* Reset the internal NewGroupID in case we are in TestMode */

    26

	AIObject::SetNewGroupID(0);

    27

    28

	bool ret = AIObject::DoCommand(0, (::VehicleType)vehicle_type, 0, CMD_CREATE_GROUP);

    29

	return ret ? (GroupID)AIObject::GetNewGroupID() : INVALID_GROUP;

    30

}

    31

    32

/* static */ bool AIGroup::DeleteGroup(GroupID group_id)

    33

{

    34

	EnforcePrecondition(false, IsValidGroup(group_id));

    35

    36

	return AIObject::DoCommand(0, group_id, 0, CMD_DELETE_GROUP);

    37

}

    38

    39

/* static */ AIVehicle::VehicleType AIGroup::GetVehicleType(GroupID group_id)

    40

{

    41

	if (!IsValidGroup(group_id)) return AIVehicle::VEHICLE_INVALID;

    42

    43

	return (AIVehicle::VehicleType)((::VehicleType)::GetGroup(group_id)->vehicle_type);

    44

}

    45

    46

/* static */ bool AIGroup::SetName(GroupID group_id, const char *name)

    47

{

    48

	EnforcePrecondition(false, IsValidGroup(group_id));

    49

	EnforcePrecondition(false, !::StrEmpty(name));

    50

    51

	_cmd_text = name;

    52

	return AIObject::DoCommand(0, group_id, 0, CMD_RENAME_GROUP);

    53

}

    54

    55

/* static */ char *AIGroup::GetName(GroupID group_id)

    56

{

    57

	if (!IsValidGroup(group_id)) return NULL;

    58

    59

	static const int len = 64;

    60

	char *group_name = MallocT<char>(len);

    61

    62

	::SetDParam(0, group_id);

    63

	::GetString(group_name, STR_GROUP_NAME, &group_name[len - 1]);

    64

	return group_name;

    65

}

    66

    67

/* static */ bool AIGroup::EnableAutoReplaceProtection(GroupID group_id, bool enable)

    68

{

    69

	EnforcePrecondition(false, IsValidGroup(group_id));

    70

    71

	return AIObject::DoCommand(0, group_id, enable ? 1 : 0, CMD_SET_GROUP_REPLACE_PROTECTION);

    72

}

    73

    74

/* static */ bool AIGroup::GetAutoReplaceProtection(GroupID group_id)

    75

{

    76

	if (!IsValidGroup(group_id)) return false;

    77

    78

	return ::GetGroup(group_id)->replace_protection;

    79

}

    80

    81

/* static */ int32 AIGroup::GetNumEngines(GroupID group_id, EngineID engine_id)

    82

{

    83

	if (!IsValidGroup(group_id) && group_id != DEFAULT_GROUP && group_id != ALL_GROUP) return -1;

    84

    85

	return GetGroupNumEngines(_current_player, group_id, engine_id);

    86

}

    87

    88

/* static */ bool AIGroup::MoveVehicle(GroupID group_id, VehicleID vehicle_id)

    89

{

    90

	EnforcePrecondition(false, IsValidGroup(group_id) || group_id == DEFAULT_GROUP);

    91

	EnforcePrecondition(false, AIVehicle::IsValidVehicle(vehicle_id));

    92

    93

	return AIObject::DoCommand(0, group_id, vehicle_id, CMD_ADD_VEHICLE_GROUP);

    94

}

    95

    96

/* static */ bool AIGroup::SetAutoReplace(GroupID group_id, EngineID engine_id_old, EngineID engine_id_new)

    97

{

    98

	EnforcePrecondition(false, IsValidGroup(group_id) || group_id == ALL_GROUP);

    99

	EnforcePrecondition(false, AIEngine::IsValidEngine(engine_id_new));

   100

   101

	return AIObject::DoCommand(0, 3 | (group_id << 16), (engine_id_new << 16) | engine_id_old, CMD_SET_AUTOREPLACE);

   102

}

   103

   104

/* static */ EngineID AIGroup::GetEngineReplacement(GroupID group_id, EngineID engine_id)

   105

{

   106

	if (!IsValidGroup(group_id) && group_id != ALL_GROUP) return ::INVALID_ENGINE;

   107

   108

	return ::EngineReplacementForPlayer(GetPlayer(_current_player), engine_id, group_id);

   109

}

   110

   111

/* static */ bool AIGroup::StopAutoReplace(GroupID group_id, EngineID engine_id)

   112

{

   113

	EnforcePrecondition(false, IsValidGroup(group_id) || group_id == ALL_GROUP);

   114

   115

	return AIObject::DoCommand(0, 3 | (group_id << 16), (::INVALID_ENGINE << 16) | engine_id, CMD_SET_AUTOREPLACE);

   116

}