1

/* $Id$ */

     2

     3

/** @file road.cpp Generic road related functions. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "rail_map.h"

     8

#include "road_map.h"

     9

#include "road_internal.h"

    10

#include "water_map.h"

    11

#include "genworld.h"

    12

#include "player_func.h"

    13

#include "player_base.h"

    14

#include "engine_func.h"

    15

#include "engine_base.h"

    16

#include "settings_type.h"

    17

#include "date_func.h"

    18

    19

bool IsPossibleCrossing(const TileIndex tile, Axis ax)

    20

{

    21

	return (IsTileType(tile, MP_RAILWAY) &&

    22

		!HasSignals(tile) &&

    23

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

    24

		GetTileSlope(tile, NULL) == SLOPE_FLAT);

    25

}

    26

    27

RoadBits CleanUpRoadBits(const TileIndex tile, RoadBits org_rb)

    28

{

    29

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

    30

		const TileIndex neighbor_tile = TileAddByDiagDir(tile, dir);

    31

    32

		/* Get the Roadbit pointing to the neighbor_tile */

    33

		const RoadBits target_rb = DiagDirToRoadBits(dir);

    34

    35

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

    36

		if (org_rb & target_rb) {

    37

			bool connective = false;

    38

			const RoadBits mirrored_rb = MirrorRoadBits(target_rb);

    39

    40

			switch (GetTileType(neighbor_tile)) {

    41

				/* Allways connective ones */

    42

				case MP_CLEAR: case MP_TREES:

    43

					connective = true;

    44

					break;

    45

    46

				/* The conditionaly connective ones */

    47

				case MP_TUNNELBRIDGE:

    48

				case MP_STATION:

    49

				case MP_ROAD: {

    50

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

    51

    52

					/* Accept only connective tiles */

    53

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

    54

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

    55

    56

				} break;

    57

    58

				case MP_RAILWAY:

    59

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

    60

					break;

    61

    62

				case MP_WATER:

    63

					/* Check for real water tile */

    64

					connective = !IsWater(neighbor_tile);

    65

					break;

    66

    67

				/* The defentetly not connective ones */

    68

				default: break;

    69

			}

    70

    71

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

    72

			if (!connective) org_rb ^= target_rb;

    73

    74

		}

    75

	}

    76

    77

	return org_rb;

    78

}

    79

    80

bool HasRoadTypesAvail(const PlayerID p, const RoadTypes rts)

    81

{

    82

	RoadTypes avail_roadtypes;

    83

    84

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

    85

		avail_roadtypes = ROADTYPES_ROAD;

    86

	} else {

    87

		if (!IsValidPlayer(p)) return false;

    88

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

    89

	}

    90

	return (rts & ~avail_roadtypes) == 0;

    91

}

    92

    93

bool ValParamRoadType(const RoadType rt)

    94

{

    95

	return HasRoadTypesAvail(_current_player, RoadTypeToRoadTypes(rt));

    96

}

    97

    98

RoadTypes GetPlayerRoadtypes(PlayerID p)

    99

{

   100

	RoadTypes rt = ROADTYPES_NONE;

   101

   102

	Engine *e;

   103

	FOR_ALL_ENGINES_OF_TYPE(e, VEH_ROAD) {

   104

		const EngineInfo *ei = &e->info;

   105

   106

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

   107

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

   108

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

   109

		}

   110

	}

   111

   112

	return rt;

   113

}