1

#include "ai_error.hpp"

     2

     3

namespace SQConvert {

     4

	/* Allow enums to be used as Squirrel parameters */

     5

	template <> AIError::ErrorCategories GetParam(ForceType<AIError::ErrorCategories>, HSQUIRRELVM vm, int index) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIError::ErrorCategories)tmp; }

     6

	template <> int Return<AIError::ErrorCategories>(HSQUIRRELVM vm, AIError::ErrorCategories res) { sq_pushinteger(vm, (int32)res); return 1; }

     7

	template <> AIError::ErrorMessages GetParam(ForceType<AIError::ErrorMessages>, HSQUIRRELVM vm, int index) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIError::ErrorMessages)tmp; }

     8

	template <> int Return<AIError::ErrorMessages>(HSQUIRRELVM vm, AIError::ErrorMessages res) { sq_pushinteger(vm, (int32)res); return 1; }

     9

    10

	/* Allow AIError to be used as Squirrel parameter */

    11

	template <> AIError *GetParam(ForceType<AIError *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIError *)instance; }

    12

	template <> AIError &GetParam(ForceType<AIError &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIError *)instance; }

    13

	template <> const AIError *GetParam(ForceType<const AIError *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIError *)instance; }

    14

	template <> const AIError &GetParam(ForceType<const AIError &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIError *)instance; }

    15

	template <> int Return<AIError *>(HSQUIRRELVM vm, AIError *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIError", res, NULL, DefSQDestructorCallback<AIError>); return 1; }

    16

}; // namespace SQConvert

    17

    18

void SQAIError_Register(Squirrel *engine) {

    19

	DefSQClass <AIError> SQAIError("AIError");

    20

	SQAIError.PreRegister(engine);

    21

	SQAIError.AddConstructor<void (AIError::*)(), 1>(engine, "x");

    22

    23

	SQAIError.DefSQConst(engine, AIError::ERR_CAT_NONE,                 "ERR_CAT_NONE");

    24

	SQAIError.DefSQConst(engine, AIError::ERR_CAT_GENERAL,              "ERR_CAT_GENERAL");

    25

	SQAIError.DefSQConst(engine, AIError::ERR_CAT_VEHICLE,              "ERR_CAT_VEHICLE");

    26

	SQAIError.DefSQConst(engine, AIError::ERR_CAT_STATION,              "ERR_CAT_STATION");

    27

	SQAIError.DefSQConst(engine, AIError::ERR_CAT_BRIDGE,               "ERR_CAT_BRIDGE");

    28

	SQAIError.DefSQConst(engine, AIError::ERR_CAT_TUNNEL,               "ERR_CAT_TUNNEL");

    29

	SQAIError.DefSQConst(engine, AIError::ERR_CAT_TILE,                 "ERR_CAT_TILE");

    30

	SQAIError.DefSQConst(engine, AIError::ERR_CAT_SIGN,                 "ERR_CAT_SIGN");

    31

	SQAIError.DefSQConst(engine, AIError::ERR_CAT_ROAD,                 "ERR_CAT_ROAD");

    32

	SQAIError.DefSQConst(engine, AIError::ERR_CAT_ORDER,                "ERR_CAT_ORDER");

    33

	SQAIError.DefSQConst(engine, AIError::ERR_CAT_MARINE,               "ERR_CAT_MARINE");

    34

	SQAIError.DefSQConst(engine, AIError::ERR_CAT_BIT_SIZE,             "ERR_CAT_BIT_SIZE");

    35

	SQAIError.DefSQConst(engine, AIError::ERR_NONE,                     "ERR_NONE");

    36

	SQAIError.DefSQConst(engine, AIError::ERR_UNKNOWN,                  "ERR_UNKNOWN");

    37

	SQAIError.DefSQConst(engine, AIError::ERR_PRECONDITION_FAILED,      "ERR_PRECONDITION_FAILED");

    38

	SQAIError.DefSQConst(engine, AIError::ERR_NEWGRF_SUPPLIED_ERROR,    "ERR_NEWGRF_SUPPLIED_ERROR");

    39

	SQAIError.DefSQConst(engine, AIError::ERR_GENERAL_BASE,             "ERR_GENERAL_BASE");

    40

	SQAIError.DefSQConst(engine, AIError::ERR_NOT_ENOUGH_CASH,          "ERR_NOT_ENOUGH_CASH");

    41

	SQAIError.DefSQConst(engine, AIError::ERR_LOCAL_AUTHORITY_REFUSES,  "ERR_LOCAL_AUTHORITY_REFUSES");

    42

	SQAIError.DefSQConst(engine, AIError::ERR_ALREADY_BUILT,            "ERR_ALREADY_BUILT");

    43

	SQAIError.DefSQConst(engine, AIError::ERR_AREA_NOT_CLEAR,           "ERR_AREA_NOT_CLEAR");

    44

	SQAIError.DefSQConst(engine, AIError::ERR_OWNED_BY_ANOTHER_COMPANY, "ERR_OWNED_BY_ANOTHER_COMPANY");

    45

	SQAIError.DefSQConst(engine, AIError::ERR_NAME_IS_NOT_UNIQUE,       "ERR_NAME_IS_NOT_UNIQUE");

    46

	SQAIError.DefSQConst(engine, AIError::ERR_FLAT_LAND_REQUIRED,       "ERR_FLAT_LAND_REQUIRED");

    47

	SQAIError.DefSQConst(engine, AIError::ERR_LAND_SLOPED_WRONG,        "ERR_LAND_SLOPED_WRONG");

    48

	SQAIError.DefSQConst(engine, AIError::ERR_VEHICLE_IN_THE_WAY,       "ERR_VEHICLE_IN_THE_WAY");

    49

	SQAIError.DefSQConst(engine, AIError::ERR_SITE_UNSUITABLE,          "ERR_SITE_UNSUITABLE");

    50

	SQAIError.DefSQConst(engine, AIError::ERR_TOO_CLOSE_TO_EDGE,        "ERR_TOO_CLOSE_TO_EDGE");

    51

    52

	AIError::RegisterErrorMap(STR_0003_NOT_ENOUGH_CASH_REQUIRES,        AIError::ERR_NOT_ENOUGH_CASH);

    53

	AIError::RegisterErrorMap(STR_2009_LOCAL_AUTHORITY_REFUSES,         AIError::ERR_LOCAL_AUTHORITY_REFUSES);

    54

	AIError::RegisterErrorMap(STR_1007_ALREADY_BUILT,                   AIError::ERR_ALREADY_BUILT);

    55

	AIError::RegisterErrorMap(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST,      AIError::ERR_ALREADY_BUILT);

    56

	AIError::RegisterErrorMap(STR_2004_BUILDING_MUST_BE_DEMOLISHED,     AIError::ERR_AREA_NOT_CLEAR);

    57

	AIError::RegisterErrorMap(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST,      AIError::ERR_AREA_NOT_CLEAR);

    58

	AIError::RegisterErrorMap(STR_300B_MUST_DEMOLISH_RAILROAD,          AIError::ERR_AREA_NOT_CLEAR);

    59

	AIError::RegisterErrorMap(STR_300E_MUST_DEMOLISH_AIRPORT_FIRST,     AIError::ERR_AREA_NOT_CLEAR);

    60

	AIError::RegisterErrorMap(STR_MUST_DEMOLISH_CARGO_TRAM_STATION,     AIError::ERR_AREA_NOT_CLEAR);

    61

	AIError::RegisterErrorMap(STR_3047_MUST_DEMOLISH_TRUCK_STATION,     AIError::ERR_AREA_NOT_CLEAR);

    62

	AIError::RegisterErrorMap(STR_MUST_DEMOLISH_PASSENGER_TRAM_STATION, AIError::ERR_AREA_NOT_CLEAR);

    63

	AIError::RegisterErrorMap(STR_3046_MUST_DEMOLISH_BUS_STATION,       AIError::ERR_AREA_NOT_CLEAR);

    64

	AIError::RegisterErrorMap(STR_306A_BUOY_IN_THE_WAY,                 AIError::ERR_AREA_NOT_CLEAR);

    65

	AIError::RegisterErrorMap(STR_304D_MUST_DEMOLISH_DOCK_FIRST,        AIError::ERR_AREA_NOT_CLEAR);

    66

	AIError::RegisterErrorMap(STR_4800_IN_THE_WAY,                      AIError::ERR_AREA_NOT_CLEAR);

    67

	AIError::RegisterErrorMap(STR_5804_COMPANY_HEADQUARTERS_IN,         AIError::ERR_AREA_NOT_CLEAR);

    68

	AIError::RegisterErrorMap(STR_5800_OBJECT_IN_THE_WAY,               AIError::ERR_AREA_NOT_CLEAR);

    69

	AIError::RegisterErrorMap(STR_1801_MUST_REMOVE_ROAD_FIRST,          AIError::ERR_AREA_NOT_CLEAR);

    70

	AIError::RegisterErrorMap(STR_1008_MUST_REMOVE_RAILROAD_TRACK,      AIError::ERR_AREA_NOT_CLEAR);

    71

	AIError::RegisterErrorMap(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST,      AIError::ERR_AREA_NOT_CLEAR);

    72

	AIError::RegisterErrorMap(STR_5006_MUST_DEMOLISH_TUNNEL_FIRST,      AIError::ERR_AREA_NOT_CLEAR);

    73

	AIError::RegisterErrorMap(STR_1002_EXCAVATION_WOULD_DAMAGE,         AIError::ERR_AREA_NOT_CLEAR);

    74

	AIError::RegisterErrorMap(STR_1024_AREA_IS_OWNED_BY_ANOTHER,        AIError::ERR_OWNED_BY_ANOTHER_COMPANY);

    75

	AIError::RegisterErrorMap(STR_013B_OWNED_BY,                        AIError::ERR_OWNED_BY_ANOTHER_COMPANY);

    76

	AIError::RegisterErrorMap(STR_NAME_MUST_BE_UNIQUE,                  AIError::ERR_NAME_IS_NOT_UNIQUE);

    77

	AIError::RegisterErrorMap(STR_0007_FLAT_LAND_REQUIRED,              AIError::ERR_FLAT_LAND_REQUIRED);

    78

	AIError::RegisterErrorMap(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION,  AIError::ERR_LAND_SLOPED_WRONG);

    79

	AIError::RegisterErrorMap(STR_8803_TRAIN_IN_THE_WAY,                AIError::ERR_VEHICLE_IN_THE_WAY);

    80

	AIError::RegisterErrorMap(STR_9000_ROAD_VEHICLE_IN_THE_WAY,         AIError::ERR_VEHICLE_IN_THE_WAY);

    81

	AIError::RegisterErrorMap(STR_980E_SHIP_IN_THE_WAY,                 AIError::ERR_VEHICLE_IN_THE_WAY);

    82

	AIError::RegisterErrorMap(STR_A015_AIRCRAFT_IN_THE_WAY,             AIError::ERR_VEHICLE_IN_THE_WAY);

    83

	AIError::RegisterErrorMap(STR_0239_SITE_UNSUITABLE,                 AIError::ERR_SITE_UNSUITABLE);

    84

	AIError::RegisterErrorMap(STR_304B_SITE_UNSUITABLE,                 AIError::ERR_SITE_UNSUITABLE);

    85

	AIError::RegisterErrorMap(STR_0002_TOO_CLOSE_TO_EDGE_OF_MAP,        AIError::ERR_TOO_CLOSE_TO_EDGE);

    86

    87

	AIError::RegisterErrorMapString(AIError::ERR_NONE,                     "ERR_NONE");

    88

	AIError::RegisterErrorMapString(AIError::ERR_UNKNOWN,                  "ERR_UNKNOWN");

    89

	AIError::RegisterErrorMapString(AIError::ERR_PRECONDITION_FAILED,      "ERR_PRECONDITION_FAILED");

    90

	AIError::RegisterErrorMapString(AIError::ERR_NEWGRF_SUPPLIED_ERROR,    "ERR_NEWGRF_SUPPLIED_ERROR");

    91

	AIError::RegisterErrorMapString(AIError::ERR_NOT_ENOUGH_CASH,          "ERR_NOT_ENOUGH_CASH");

    92

	AIError::RegisterErrorMapString(AIError::ERR_LOCAL_AUTHORITY_REFUSES,  "ERR_LOCAL_AUTHORITY_REFUSES");

    93

	AIError::RegisterErrorMapString(AIError::ERR_ALREADY_BUILT,            "ERR_ALREADY_BUILT");

    94

	AIError::RegisterErrorMapString(AIError::ERR_AREA_NOT_CLEAR,           "ERR_AREA_NOT_CLEAR");

    95

	AIError::RegisterErrorMapString(AIError::ERR_OWNED_BY_ANOTHER_COMPANY, "ERR_OWNED_BY_ANOTHER_COMPANY");

    96

	AIError::RegisterErrorMapString(AIError::ERR_NAME_IS_NOT_UNIQUE,       "ERR_NAME_IS_NOT_UNIQUE");

    97

	AIError::RegisterErrorMapString(AIError::ERR_FLAT_LAND_REQUIRED,       "ERR_FLAT_LAND_REQUIRED");

    98

	AIError::RegisterErrorMapString(AIError::ERR_LAND_SLOPED_WRONG,        "ERR_LAND_SLOPED_WRONG");

    99

	AIError::RegisterErrorMapString(AIError::ERR_VEHICLE_IN_THE_WAY,       "ERR_VEHICLE_IN_THE_WAY");

   100

	AIError::RegisterErrorMapString(AIError::ERR_SITE_UNSUITABLE,          "ERR_SITE_UNSUITABLE");

   101

	AIError::RegisterErrorMapString(AIError::ERR_TOO_CLOSE_TO_EDGE,        "ERR_TOO_CLOSE_TO_EDGE");

   102

   103

	SQAIError.DefSQStaticMethod(engine, &AIError::GetClassName,           "GetClassName",           1, "x");

   104

	SQAIError.DefSQStaticMethod(engine, &AIError::GetErrorCategory,       "GetErrorCategory",       1, "x");

   105

	SQAIError.DefSQStaticMethod(engine, &AIError::GetLastError,           "GetLastError",           1, "x");

   106

	SQAIError.DefSQStaticMethod(engine, &AIError::GetLastErrorString,     "GetLastErrorString",     1, "x");

   107

	SQAIError.DefSQStaticMethod(engine, &AIError::StringToError,          "StringToError",          2, "xi");

   108

	SQAIError.DefSQStaticMethod(engine, &AIError::RegisterErrorMap,       "RegisterErrorMap",       3, "xii");

   109

	SQAIError.DefSQStaticMethod(engine, &AIError::RegisterErrorMapString, "RegisterErrorMapString", 3, "xis");

   110

   111

	SQAIError.PostRegister(engine);

   112

}