1

#ifndef AI_NEW_H

     2

#define AI_NEW_H

     3

     4

#include "aystar.h"

     6

     7

/*

     8

 * These defines can be altered to change the behavoir of the AI

     9

 *

    10

 * WARNING:

    11

 *   This can also alter the AI in a negative way. I will never claim these settings

    12

 *   are perfect, but don't change them if you don't know what the effect is.

    13

 */

    14

    15

// How many times it the H multiplied. The higher, the more it will go straight to the

    16

//   end point. The lower, how more it will find the route with the lowest cost.

    17

//   also: the lower, the longer it takes before route is calculated..

    18

#define AI_PATHFINDER_H_MULTIPLER 100

    19

    20

// How many loops may AyStar do before it stops

    21

//   0 = infinite

    22

#define AI_PATHFINDER_LOOPS_PER_TICK 5

    23

    24

// How long may the AI search for one route?

    25

//   0 = infinite

    26

// This number is the number of tiles tested.

    27

//  It takes (AI_PATHFINDER_MAX_SEARCH_NODES / AI_PATHFINDER_LOOPS_PER_TICK) ticks

    28

//  to get here.. with 5000 / 10 = 500. 500 / 74 (one day) = 8 days till it aborts

    29

//   (that is: if the AI is on VERY FAST! :p

    30

#define AI_PATHFINDER_MAX_SEARCH_NODES 5000

    31

    32

// If you enable this, the AI is not allowed to make 90degree turns

    33

#define AI_PATHFINDER_NO_90DEGREES_TURN

    34

    35

// Below are defines for the g-calculation

    36

    37

// Standard penalty given to a tile

    38

#define AI_PATHFINDER_PENALTY 150

    39

// The penalty given to a tile that is going up

    40

#define AI_PATHFINDER_TILE_GOES_UP_PENALTY 450

    41

// The penalty given to a tile which would have to use fundation

    42

#define AI_PATHFINDER_FOUNDATION_PENALTY 100

    43

// Changing direction is a penalty, to prevent curved ways (with that: slow ways)

    44

#define AI_PATHFINDER_DIRECTION_CHANGE_PENALTY 200

    45

// Same penalty, only for when road already exists

    46

#define AI_PATHFINDER_DIRECTION_CHANGE_ON_EXISTING_ROAD_PENALTY 50

    47

// A diagonal track cost the same as a straigh, but a diagonal is faster... so give

    48

//  a bonus for using diagonal track

    49

#ifdef AI_PATHFINDER_NO_90DEGREES_TURN

    50

#define AI_PATHFINDER_DIAGONAL_BONUS 95

    51

#else

    52

#define AI_PATHFINDER_DIAGONAL_BONUS 75

    53

#endif

    54

// If a roadblock already exists, it gets a bonus

    55

#define AI_PATHFINDER_ROAD_ALREADY_EXISTS_BONUS 140

    56

// To prevent 3 direction changes in 3 tiles, this penalty is given in such situation

    57

#define AI_PATHFINDER_CURVE_PENALTY 200

    58

    59

// Penalty a bridge gets per length

    60

#define AI_PATHFINDER_BRIDGE_PENALTY 180

    61

// The penalty for a bridge going up

    62

#define AI_PATHFINDER_BRIDGE_GOES_UP_PENALTY 1000

    63

    64

// Tunnels are expensive...

    65

//  Because of that, every tile the cost is increased with 1/8th of his value

    66

//  This is also true if you are building a tunnel yourself

    67

#define AI_PATHFINDER_TUNNEL_PENALTY 350

    68

    69

/*

    70

 * Ai_New defines

    71

 */

    72

    73

// How long may we search cities and industry for a new route?

    74

#define AI_LOCATE_ROUTE_MAX_COUNTER 200

    75

    76

// How many days must there be between building the first station and the second station

    77

//  within one city. This number is in days and should be more than 4 months.

    78

#define AI_CHECKCITY_DATE_BETWEEN 180

    79

    80

// How many cargo is needed for one station in a city?

    81

#define AI_CHECKCITY_CARGO_PER_STATION 60

    82

// How much cargo must there not be used in a city before we can build a new station?

    83

#define AI_CHECKCITY_NEEDED_CARGO 50

    84

// When there is already a station which takes the same good and the rating of that

    85

//  city is higher then this numer, we are not going to attempt to build anything

    86

//  there

    87

#define AI_CHECKCITY_CARGO_RATING 50

    88

// But, there is a chance of 1 out of this number, that we do ;)

    89

#define AI_CHECKCITY_CARGO_RATING_CHANCE 5

    90

// If a city is too small to contain a station, there is a small chance

    91

//  that we still do so.. just to make the city bigger!

    92

#define AI_CHECKCITY_CITY_CHANCE 5

    93

    94

// This number indicates for every unit of cargo, how many tiles two stations maybe be away

    95

//  from eachother. In other words: if we have 120 units of cargo in one station, and 120 units

    96

//  of the cargo in the other station, both stations can be 96 units away from eachother, if the

    97

//  next number is 0.4.

    98

#define AI_LOCATEROUTE_BUS_CARGO_DISTANCE 0.4

    99

#define AI_LOCATEROUTE_TRUCK_CARGO_DISTANCE 0.7

   100

// In whole tiles, the minimum distance for a truck route

   101

#define AI_LOCATEROUTE_TRUCK_MIN_DISTANCE 30

   102

   103

// The amount of tiles in a square from -X to +X that is scanned for a station spot

   104

//  (so if this number is 10, 20x20 = 400 tiles are scanned for _the_ perfect spot

   105

// Safe values are between 15 and 5

   106

#define AI_FINDSTATION_TILE_RANGE 10

   107

   108

// Building on normal speed goes very fast. Idle this amount of ticks between every

   109

//  building part. It is calculated like this: (4 - competitor_speed) * num + 1

   110

//  where competitor_speed is between 0 (very slow) to 4 (very fast)

   111

#define AI_BUILDPATH_PAUSE 10

   112

   113

// Minimum % of reliabilty a vehicle has to have before the AI buys it

   114

#define AI_VEHICLE_MIN_RELIABILTY 60

   115

   116

// The minimum amount of money a player should always have

   117

#define AI_MINIMUM_MONEY 15000

   118

   119

// If the most cheap route is build, how much is it going to cost..

   120

// This is to prevent the AI from trying to build a route which can not be paid for

   121

#define AI_MINIMUM_BUS_ROUTE_MONEY 25000

   122

#define AI_MINIMUM_TRUCK_ROUTE_MONEY 35000

   123

   124

// The minimum amount of money before we are going to repay any money

   125

#define AI_MINIMUM_LOAN_REPAY_MONEY 40000

   126

// How many repays do we do if we have enough money to do so?

   127

//  Every repay is 10000

   128

#define AI_LOAN_REPAY 2

   129

// How much income must we have before paying back a loan? Month-based (and looked at the last month)

   130

#define AI_MINIMUM_INCOME_FOR_LOAN 7000

   131

   132

// If there is <num> time as much cargo in the station then the vehicle can handle

   133

//  reuse the station instead of building a new one!

   134

#define AI_STATION_REUSE_MULTIPLER 2

   135

   136

// No more than this amount of vehicles per station..

   137

#define AI_CHECK_MAX_VEHICLE_PER_STATION 10

   138

   139

// How many thick between building 2 vehicles

   140

#define AI_BUILD_VEHICLE_TIME_BETWEEN DAY_TICKS

   141

   142

// How many days must there between vehicle checks

   143

//  The more often, the less non-money-making lines there will be

   144

//   but the unfair it may seem to a human player

   145

#define AI_DAYS_BETWEEN_VEHICLE_CHECKS 30

   146

   147

// How money profit does a vehicle needs to make to stay in order

   148

//  This is the profit of this year + profit of last year

   149

//  But also for vehicles that are just one year old. In other words:

   150

//   Vehicles of 2 years do easier meet this setting then vehicles

   151

//   of one year. This is a very good thing. New vehicles are filtered,

   152

//   while old vehicles stay longer, because we do get less in return.

   153

#define AI_MINIMUM_ROUTE_PROFIT 1000

   154

   155

// A vehicle is considered lost when he his cargo is more than 180 days old

   156

#define AI_VEHICLE_LOST_DAYS 180

   157

   158

// How many times may the AI try to find a route before it gives up

   159

#define AI_MAX_TRIES_FOR_SAME_ROUTE 8

   160

   161

/*

   162

 * End of defines

   163

 */

   164

   165

// This stops 90degrees curves

   166

static const byte _illegal_curves[6] = {

   167

    255, 255, // Horz and vert, don't have the effect

   168

    5, // upleft and upright are not valid

   169

    4, // downright and downleft are not valid

   170

    2, // downleft and upleft are not valid

   171

    3, // upright and downright are not valid

   172

};

   173

   174

enum {

   175

    AI_STATE_STARTUP = 0,

   176

    AI_STATE_FIRST_TIME,

   177

    AI_STATE_NOTHING,

   178

    AI_STATE_WAKE_UP,

   179

    AI_STATE_LOCATE_ROUTE,

   180

    AI_STATE_FIND_STATION,

   181

    AI_STATE_FIND_PATH,

   182

    AI_STATE_FIND_DEPOT,

   183

    AI_STATE_VERIFY_ROUTE,

   184

    AI_STATE_BUILD_STATION,

   185

    AI_STATE_BUILD_PATH,

   186

    AI_STATE_BUILD_DEPOT,

   187

    AI_STATE_BUILD_VEHICLE,

   188

    AI_STATE_GIVE_ORDERS,

   189

    AI_STATE_START_VEHICLE,

   190

    AI_STATE_REPAY_MONEY,

   191

	AI_STATE_CHECK_ALL_VEHICLES,

   192

    AI_STATE_ACTION_DONE,

   193

    AI_STATE_STOP, // Temporary function to stop the AI

   194

};

   195

   196

// Used for tbt (train/bus/truck)

   197

enum {

   198

	AI_TRAIN = 0,

   199

	AI_BUS,

   200

	AI_TRUCK,

   201

};

   202

   203

enum {

   204

	AI_ACTION_NONE = 0,

   205

	AI_ACTION_BUS_ROUTE,

   206

	AI_ACTION_TRUCK_ROUTE,

   207

	AI_ACTION_REPAY_LOAN,

   208

	AI_ACTION_CHECK_ALL_VEHICLES,

   209

};

   210

   211

// Used for from_type/to_type

   212

enum {

   213

    AI_NO_TYPE = 0,

   214

	AI_CITY,

   215

	AI_INDUSTRY,

   216

};

   217

   218

// Flags for in the vehicle

   219

enum {

   220

	AI_VEHICLEFLAG_SELL = 1,

   221

	// Remember, flags must be in power of 2

   222

};

   223

   224

#define AI_NO_CARGO 0xFF // Means that there is no cargo defined yet (used for industry)

   225

#define AI_NEED_CARGO 0xFE // Used when the AI needs to find out a cargo for the route

   226

#define AI_STATION_RANGE TileXY(MapMaxX(), MapMaxY())

   227

   228

#define AI_PATHFINDER_NO_DIRECTION (byte)-1

   229

   230

// Flags used in user_data

   231

#define AI_PATHFINDER_FLAG_BRIDGE 1

   232

#define AI_PATHFINDER_FLAG_TUNNEL 2

   233

   234

typedef void AiNew_StateFunction(Player *p);

   235

   236

// ai_new.c

   237

void AiNewDoGameLoop(Player *p);

   238

   239

// ai_pathfinder.c

   240

AyStar *new_AyStar_AiPathFinder(int max_tiles_around, Ai_PathFinderInfo *PathFinderInfo);

   241

void clean_AyStar_AiPathFinder(AyStar *aystar, Ai_PathFinderInfo *PathFinderInfo);

   242

   243

// ai_shared.c

   244

int AiNew_GetRailDirection(TileIndex tile_a, TileIndex tile_b, TileIndex tile_c);

   245

int AiNew_GetRoadDirection(TileIndex tile_a, TileIndex tile_b, TileIndex tile_c);

   246

int AiNew_GetDirection(TileIndex tile_a, TileIndex tile_b);

   247

bool AiNew_SetSpecialVehicleFlag(Player *p, Vehicle *v, uint flag);

   248

uint AiNew_GetSpecialVehicleFlag(Player *p, Vehicle *v);

   249

   250

// ai_build.c

   251

bool AiNew_Build_CompanyHQ(Player *p, TileIndex tile);

   252

int AiNew_Build_Station(Player *p, byte type, TileIndex tile, byte length, byte numtracks, byte direction, byte flag);

   253

int AiNew_Build_Bridge(Player *p, TileIndex tile_a, TileIndex tile_b, byte flag);

   254

int AiNew_Build_RoutePart(Player *p, Ai_PathFinderInfo *PathFinderInfo, byte flag);

   255

int AiNew_PickVehicle(Player *p);

   256

int AiNew_Build_Vehicle(Player *p, TileIndex tile, byte flag);

   257

int AiNew_Build_Depot(Player *p, TileIndex tile, byte direction, byte flag);

   258

   259

#endif /* AI_NEW_H */