1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "rail_map.h"

     6

#include "road_map.h"

     7

#include "road_internal.h"

     8

#include "water_map.h"

     9

#include "genworld.h"

    10

#include "player_func.h"

    11

#include "player_base.h"

    12

#include "engine_func.h"

    13

#include "settings_type.h"

    14

#include "date_func.h"

    15

    16

bool IsPossibleCrossing(const TileIndex tile, Axis ax)

    17

{

    18

	return (IsTileType(tile, MP_RAILWAY) &&

    19

		!HasSignals(tile) &&

    20

		GetTrackBits(tile) == (ax == AXIS_X ?  TRACK_BIT_Y : TRACK_BIT_X) &&

    21

		GetTileSlope(tile, NULL) == SLOPE_FLAT);

    22

}

    23

    24

RoadBits CleanUpRoadBits(const TileIndex tile, RoadBits org_rb)

    25

{

    26

	for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {

    27

		const TileIndex neighbor_tile = TileAddByDiagDir(tile, dir);

    28

    29

		/* Get the Roadbit pointing to the neighbor_tile */

    30

		const RoadBits target_rb = DiagDirToRoadBits(dir);

    31

    32

		/* If the roadbit is in the current plan */

    33

		if (org_rb & target_rb) {

    34

			bool connective = false;

    35

			const RoadBits mirrored_rb = MirrorRoadBits(target_rb);

    36

    37

			switch (GetTileType(neighbor_tile)) {

    38

				/* Allways connective ones */

    39

				case MP_CLEAR: case MP_TREES:

    40

					connective = true;

    41

					break;

    42

    43

				/* The conditionaly connective ones */

    44

				case MP_TUNNELBRIDGE:

    45

				case MP_STATION:

    46

				case MP_ROAD: {

    47

					const RoadBits neighbor_rb = GetAnyRoadBits(neighbor_tile, ROADTYPE_ROAD) | GetAnyRoadBits(neighbor_tile, ROADTYPE_TRAM);

    48

    49

					/* Accept only connective tiles */

    50

					connective = (neighbor_rb & mirrored_rb) || // Neighbor has got the fitting RoadBit

    51

							CountBits(neighbor_rb) == 1; // Neighbor has got only one Roadbit

    52

    53

				} break;

    54

    55

				case MP_RAILWAY:

    56

					connective = IsPossibleCrossing(neighbor_tile, DiagDirToAxis(dir));

    57

					break;

    58

    59

				case MP_WATER:

    60

					/* Check for real water tile */

    61

					connective = !IsWater(neighbor_tile);

    62

					break;

    63

    64

				/* The defentetly not connective ones */

    65

				default: break;

    66

			}

    67

    68

			/* If the neighbor tile is inconnective remove the planed road connection to it */

    69

			if (!connective) org_rb ^= target_rb;

    70

    71

		}

    72

	}

    73

    74

	return org_rb;

    75

}

    76

    77

bool HasRoadTypesAvail(const PlayerID p, const RoadTypes rts)

    78

{

    79

	RoadTypes avail_roadtypes;

    80

    81

	if (p == OWNER_TOWN || _game_mode == GM_EDITOR || IsGeneratingWorld()) {

    82

		avail_roadtypes = ROADTYPES_ROAD;

    83

	} else {

    84

		if (!IsValidPlayer(p)) return false;

    85

		avail_roadtypes = (RoadTypes)GetPlayer(p)->avail_roadtypes | ROADTYPES_ROAD; // road is available for always for everybody

    86

	}

    87

	return (rts & ~avail_roadtypes) == 0;

    88

}

    89

    90

bool ValParamRoadType(const RoadType rt)

    91

{

    92

	return HasRoadTypesAvail(_current_player, RoadTypeToRoadTypes(rt));

    93

}

    94

    95

RoadTypes GetPlayerRoadtypes(PlayerID p)

    96

{

    97

	RoadTypes rt = ROADTYPES_NONE;

    98

    99

	EngineID i;

   100

	FOR_ALL_ENGINEIDS_OF_TYPE(i, VEH_ROAD) {

   101

		const Engine* e = GetEngine(i);

   102

		const EngineInfo *ei = EngInfo(i);

   103

   104

		if (HasBit(ei->climates, _opt.landscape) &&

   105

				(HasBit(e->player_avail, p) || _date >= e->intro_date + 365)) {

   106

			SetBit(rt, HasBit(ei->misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD);

   107

		}

   108

	}

   109

   110

	return rt;

   111

}