1

/* $Id$ */

     2

     3

/** @file trolly.h Functions/defines related to the trolly AI. */

     4

     5

#ifndef AI_TROLLY_H

     6

#define AI_TROLLY_H

     7

     8

#include "../../aystar.h"

     9

#include "../../player_type.h"

    10

#include "../../vehicle_type.h"

    11

#include "../../date_type.h"

    12

#include "../../engine_type.h"

    13

    14

/*

    15

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

    16

 *

    17

 * WARNING:

    18

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

    19

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

    20

 */

    21

    22

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

    23

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

    24

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

    25

#define AI_PATHFINDER_H_MULTIPLER 100

    26

    27

// How many loops may AyStar do before it stops

    28

//   0 = infinite

    29

#define AI_PATHFINDER_LOOPS_PER_TICK 5

    30

    31

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

    32

//   0 = infinite

    33

// This number is the number of tiles tested.

    34

//  It takes (AI_PATHFINDER_MAX_SEARCH_NODES / AI_PATHFINDER_LOOPS_PER_TICK) ticks

    35

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

    36

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

    37

#define AI_PATHFINDER_MAX_SEARCH_NODES 5000

    38

    39

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

    40

#define AI_PATHFINDER_NO_90DEGREES_TURN

    41

    42

// Below are defines for the g-calculation

    43

    44

// Standard penalty given to a tile

    45

#define AI_PATHFINDER_PENALTY 150

    46

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

    47

#define AI_PATHFINDER_TILE_GOES_UP_PENALTY 450

    48

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

    49

#define AI_PATHFINDER_FOUNDATION_PENALTY 100

    50

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

    51

#define AI_PATHFINDER_DIRECTION_CHANGE_PENALTY 200

    52

// Same penalty, only for when road already exists

    53

#define AI_PATHFINDER_DIRECTION_CHANGE_ON_EXISTING_ROAD_PENALTY 50

    54

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

    55

//  a bonus for using diagonal track

    56

#ifdef AI_PATHFINDER_NO_90DEGREES_TURN

    57

#define AI_PATHFINDER_DIAGONAL_BONUS 95

    58

#else

    59

#define AI_PATHFINDER_DIAGONAL_BONUS 75

    60

#endif

    61

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

    62

#define AI_PATHFINDER_ROAD_ALREADY_EXISTS_BONUS 140

    63

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

    64

#define AI_PATHFINDER_CURVE_PENALTY 200

    65

    66

// Penalty a bridge gets per length

    67

#define AI_PATHFINDER_BRIDGE_PENALTY 180

    68

// The penalty for a bridge going up

    69

#define AI_PATHFINDER_BRIDGE_GOES_UP_PENALTY 1000

    70

    71

// Tunnels are expensive...

    72

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

    73

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

    74

#define AI_PATHFINDER_TUNNEL_PENALTY 350

    75

    76

/*

    77

 * Ai_New defines

    78

 */

    79

    80

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

    81

#define AI_LOCATE_ROUTE_MAX_COUNTER 200

    82

    83

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

    84

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

    85

#define AI_CHECKCITY_DATE_BETWEEN 180

    86

    87

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

    88

#define AI_CHECKCITY_CARGO_PER_STATION 60

    89

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

    90

#define AI_CHECKCITY_NEEDED_CARGO 50

    91

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

    92

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

    93

//  there

    94

#define AI_CHECKCITY_CARGO_RATING 50

    95

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

    96

#define AI_CHECKCITY_CARGO_RATING_CHANCE 5

    97

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

    98

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

    99

#define AI_CHECKCITY_CITY_CHANCE 5

   100

   101

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

   102

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

   103

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

   104

//  next number is 0.4.

   105

#define AI_LOCATEROUTE_BUS_CARGO_DISTANCE 0.4

   106

#define AI_LOCATEROUTE_TRUCK_CARGO_DISTANCE 0.7

   107

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

   108

#define AI_LOCATEROUTE_TRUCK_MIN_DISTANCE 30

   109

   110

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

   111

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

   112

// Safe values are between 15 and 5

   113

#define AI_FINDSTATION_TILE_RANGE 10

   114

   115

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

   116

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

   117

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

   118

#define AI_BUILDPATH_PAUSE 10

   119

   120

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

   121

#define AI_VEHICLE_MIN_RELIABILTY 60

   122

   124

#define AI_MINIMUM_MONEY 15000

   125

   126

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

   127

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

   128

#define AI_MINIMUM_BUS_ROUTE_MONEY 25000

   129

#define AI_MINIMUM_TRUCK_ROUTE_MONEY 35000

   130

   131

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

   132

#define AI_MINIMUM_LOAN_REPAY_MONEY 40000

   133

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

   134

//  Every repay is 10000

   135

#define AI_LOAN_REPAY 2

   136

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

   137

#define AI_MINIMUM_INCOME_FOR_LOAN 7000

   138

   139

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

   140

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

   141

#define AI_STATION_REUSE_MULTIPLER 2

   142

   143

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

   144

#define AI_CHECK_MAX_VEHICLE_PER_STATION 10

   145

   146

// How many thick between building 2 vehicles

   147

#define AI_BUILD_VEHICLE_TIME_BETWEEN DAY_TICKS

   148

   149

// How many days must there between vehicle checks

   150

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

   152

#define AI_DAYS_BETWEEN_VEHICLE_CHECKS 30

   153

   154

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

   155

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

   156

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

   157

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

   158

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

   159

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

   160

#define AI_MINIMUM_ROUTE_PROFIT 1000

   161

   162

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

   163

#define AI_VEHICLE_LOST_DAYS 180

   164

   165

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

   166

#define AI_MAX_TRIES_FOR_SAME_ROUTE 8

   167

   168

/*

   169

 * End of defines

   170

 */

   171

   172

// This stops 90degrees curves

   173

static const byte _illegal_curves[6] = {

   174

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

   175

	5, // upleft and upright are not valid

   176

	4, // downright and downleft are not valid

   177

	2, // downleft and upleft are not valid

   178

	3, // upright and downright are not valid

   179

};

   180

   181

enum {

   182

	AI_STATE_STARTUP = 0,

   183

	AI_STATE_FIRST_TIME,

   184

	AI_STATE_NOTHING,

   185

	AI_STATE_WAKE_UP,

   186

	AI_STATE_LOCATE_ROUTE,

   187

	AI_STATE_FIND_STATION,

   188

	AI_STATE_FIND_PATH,

   189

	AI_STATE_FIND_DEPOT,

   190

	AI_STATE_VERIFY_ROUTE,

   191

	AI_STATE_BUILD_STATION,

   192

	AI_STATE_BUILD_PATH,

   193

	AI_STATE_BUILD_DEPOT,

   194

	AI_STATE_BUILD_VEHICLE,

   195

	AI_STATE_WAIT_FOR_BUILD,

   196

	AI_STATE_GIVE_ORDERS,

   197

	AI_STATE_START_VEHICLE,

   198

	AI_STATE_REPAY_MONEY,

   199

	AI_STATE_CHECK_ALL_VEHICLES,

   200

	AI_STATE_ACTION_DONE,

   201

	AI_STATE_STOP, // Temporary function to stop the AI

   202

};

   203

   204

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

   205

enum {

   206

	AI_TRAIN = 0,

   207

	AI_BUS,

   208

	AI_TRUCK,

   209

};

   210

   211

enum {

   212

	AI_ACTION_NONE = 0,

   213

	AI_ACTION_BUS_ROUTE,

   214

	AI_ACTION_TRUCK_ROUTE,

   215

	AI_ACTION_REPAY_LOAN,

   216

	AI_ACTION_CHECK_ALL_VEHICLES,

   217

};

   218

   219

// Used for from_type/to_type

   220

enum {

   221

	AI_NO_TYPE = 0,

   222

	AI_CITY,

   223

	AI_INDUSTRY,

   224

};

   225

   226

// Flags for in the vehicle

   227

enum {

   228

	AI_VEHICLEFLAG_SELL = 1,

   229

	// Remember, flags must be in power of 2

   230

};

   231

   232

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

   233

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

   234

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

   235

   236

#define AI_PATHFINDER_NO_DIRECTION (byte)-1

   237

   238

// Flags used in user_data

   239

#define AI_PATHFINDER_FLAG_BRIDGE 1

   240

#define AI_PATHFINDER_FLAG_TUNNEL 2

   241

   243

   244

// ai_new.c

   246

   247

struct Ai_PathFinderInfo {

   248

	TileIndex start_tile_tl; ///< tl = top-left

   249

	TileIndex start_tile_br; ///< br = bottom-right

   250

	TileIndex end_tile_tl;   ///< tl = top-left

   251

	TileIndex end_tile_br;   ///< br = bottom-right

   252

	DiagDirection start_direction; ///< 0 to 3 or AI_PATHFINDER_NO_DIRECTION

   253

	DiagDirection end_direction;   ///< 0 to 3 or AI_PATHFINDER_NO_DIRECTION

   254

   255

	TileIndex route[500];

   256

	byte route_extra[500];   ///< Some extra information about the route like bridge/tunnel

   257

	int route_length;

   258

	int position;            ///< Current position in the build-path, needed to build the path

   259

   260

	bool rail_or_road;       ///< true = rail, false = road

   261

};

   262

   263

// ai_pathfinder.c

   264

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

   265

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

   266

   267

// ai_shared.c

   268

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

   269

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

   270

DiagDirection AiNew_GetDirection(TileIndex tile_a, TileIndex tile_b);

   273

   274

// ai_build.c

   282

   283

/* The amount of memory reserved for the AI-special-vehicles */

   284

#define AI_MAX_SPECIAL_VEHICLES 100

   285

   286

struct Ai_SpecialVehicle {

   287

	VehicleID veh_id;

   288

	uint32 flag;

   289

};

   290

   292

	uint8 state;

   293

	uint tick;

   294

	uint idle;

   295

   296

	int temp;    ///< A value used in more than one function, but it just temporary

   297

	             ///< The use is pretty simple: with this we can 'think' about stuff

   298

	             ///<   in more than one tick, and more than one AI. A static will not

   299

	             ///<   do, because they are not saved. This way, the AI is almost human ;)

   300

	int counter; ///< For the same reason as temp, we have counter. It can count how

   301

	             ///<  long we are trying something, and just abort if it takes too long

   302

   303

	/* Pathfinder stuff */

   304

	Ai_PathFinderInfo path_info;

   305

	AyStar *pathfinder;

   306

   307

	/* Route stuff */

   308

   309

	CargoID cargo;

   310

	byte tbt;    ///< train/bus/truck 0/1/2 AI_TRAIN/AI_BUS/AI_TRUCK

   311

	Money new_cost;

   312

   313

	byte action;

   314

   315

	int last_id; ///< here is stored the last id of the searched city/industry

   316

	Date last_vehiclecheck_date; // Used in CheckVehicle

   317

	Ai_SpecialVehicle special_vehicles[AI_MAX_SPECIAL_VEHICLES]; ///< Some vehicles have some special flags

   318

   319

	TileIndex from_tile;

   320

	TileIndex to_tile;

   321

   322

	DiagDirectionByte from_direction;

   323

	DiagDirectionByte to_direction;

   324

   325

	bool from_deliver; ///< True if this is the station that GIVES cargo

   326

	bool to_deliver;

   327

   328

	TileIndex depot_tile;

   329

	DiagDirectionByte depot_direction;

   330

   331

	byte amount_veh;       ///< How many vehicles we are going to build in this route

   332

	byte cur_veh;          ///< How many vehicles did we bought?

   333

	VehicleID veh_id;      ///< Used when bought a vehicle

   334

	VehicleID veh_main_id; ///< The ID of the first vehicle, for shared copy

   335

   336

	int from_ic;           ///< ic = industry/city. This is the ID of them

   337

	byte from_type;        ///< AI_NO_TYPE/AI_CITY/AI_INDUSTRY

   338

	int to_ic;

   339

	byte to_type;

   340

};

   342

   343

#endif /* AI_TROLLY_H */